Файловый менеджер - Редактировать - /usr/share/Modules/libexec/modulecmd.tcl
Ðазад
#!/usr/bin/tclsh # # MODULECMD.TCL, a pure TCL implementation of the module command # Copyright (C) 2002-2004 Mark Lakata # Copyright (C) 2004-2017 Kent Mein # Copyright (C) 2016-2020 Xavier Delaruelle # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see <http://www.gnu.org/licenses/>. ########################################################################## # # Some Global Variables..... # set error_count 0 ;# Start with 0 errors set g_return_false 0 ;# False value is rendered if == 1 set g_autoInit 0 set g_inhibit_interp 0 ;# Modulefile interpretation disabled if == 1 set g_inhibit_errreport 0 ;# Non-critical error reporting disabled if == 1 set CSH_LIMIT 4000 ;# Workaround for commandline limits in csh set reportfd stderr ;# File descriptor to use to report messages set g_report_format plain ;# Output report format # Configuration option properties (superseding environment variable, default # value, is configuration lockable to default value, valid value list?, # internal value representation?, proc to call to initialize option value array set g_config_defs [list\ contact {MODULECONTACT root@localhost 0}\ auto_handling {MODULES_AUTO_HANDLING 0 0 {0 1}}\ avail_indepth {MODULES_AVAIL_INDEPTH 1 0 {0 1}}\ avail_report_dir_sym {{} 1 0}\ avail_report_mfile_sym {{} 1 0}\ collection_pin_version {MODULES_COLLECTION_PIN_VERSION 0 0 {0 1}}\ collection_target {MODULES_COLLECTION_TARGET <undef> 0}\ color {MODULES_COLOR never 0 {never auto always} {0 1 2} initConfColor}\ colors {MODULES_COLORS {} 0 {} {} initConfColors}\ extra_siteconfig {MODULES_SITECONFIG <undef> 1 {}}\ home {MODULESHOME /usr/share/Modules 0}\ icase {MODULES_ICASE never 0 {never search always}}\ ignored_dirs {{} {CVS RCS SCCS .svn .git .SYNC .sos} 0}\ locked_configs {{} {} 0}\ ml {MODULES_ML 1 0 {0 1}}\ pager {MODULES_PAGER {/usr/bin/less -eFKRX} 0}\ rcfile {MODULERCFILE <undef> 0}\ run_quarantine {MODULES_RUN_QUARANTINE <undef> 0}\ silent_shell_debug {MODULES_SILENT_SHELL_DEBUG <undef> 0 {0 1}}\ siteconfig {{} /etc/environment-modules/siteconfig.tcl 0}\ tcl_ext_lib {{} /usr/lib64/libtclenvmodules.so 0}\ term_background {MODULES_TERM_BACKGROUND dark 0 {dark light}}\ unload_match_order {MODULES_UNLOAD_MATCH_ORDER returnlast 0\ {returnlast returnfirst}}\ implicit_default {MODULES_IMPLICIT_DEFAULT 1 1 {0 1}}\ extended_default {MODULES_EXTENDED_DEFAULT 0 0 {0 1}}\ advanced_version_spec {MODULES_ADVANCED_VERSION_SPEC 0 0 {0\ 1}}\ search_match {MODULES_SEARCH_MATCH starts_with 0 {starts_with contains}}\ set_shell_startup {MODULES_SET_SHELL_STARTUP 0 0 {0 1}}\ verbosity {MODULES_VERBOSITY normal 0 {silent concise normal verbose\ debug}}\ wa_277 {MODULES_WA_277 0 0 {0 1}}\ ] proc isConfigLocked {option} { return [expr {[lsearch -exact [getConf locked_configs] $option] != -1}] } # Get configuration option value proc getConf {option {valifundef {}}} { if {![info exists ::g_configs($option)]} { # fetch option properties (including its default value) lassign $::g_config_defs($option) envvar value islockable validvallist\ intvallist initproc # ensure option is not locked before superseding its default value if {!$islockable || ![isConfigLocked $option]} { # call specific proc to initialize config option if any if {$initproc ne {}} { set value [$initproc $envvar $value $validvallist $intvallist] } else { # overriden value coming from environment if {$envvar ne {} && [info exists ::env($envvar)]} { # ignore non-valid values if {[llength $validvallist] == 0 || [isInList $validvallist\ $::env($envvar)]} { set value $::env($envvar) } } # overriden value coming the command-line if {[info exists ::asked_$option]} { set value [set ::asked_$option] } # convert value to its internal representation if {[llength $intvallist] > 0} { set value [lindex $intvallist [lsearch -exact $validvallist\ $value]] } } } # return passed value if undefined and no value record if {$value eq {<undef>}} { set value $valifundef } else { setConf $option $value } return $value } else { return $::g_configs($option) } } # Set configuration option value proc setConf {option value} { set ::g_configs($option) $value reportDebug "$option set to '$value'" } # Unset configuration option value if it is set proc unsetConf {option} { if {[info exists ::g_configs($option)]} { unset ::g_configs($option) reportDebug "$option unset" } } # Append each passed value to the existing config option value list proc lappendConf {option args} { # retrieve current value through getConf to initialize it if still undef set value [getConf $option] eval appendNoDupToList value $args setConf $option $value } # Source site config which can be used to define global procedures or # settings. We first look for the global siteconfig, then if an extra # siteconfig is defined and allowed, source that file if it exists proc sourceSiteConfig {} { lappend siteconfiglist [getConf siteconfig] for {set i 0} {$i < [llength $siteconfiglist]} {incr i} { set siteconfig [lindex $siteconfiglist $i] if {[file readable $siteconfig]} { reportDebug "Source site configuration ($siteconfig)" if {[catch {uplevel 1 source $siteconfig} errMsg]} { set errMsg "Site configuration source failed\n" # issue line number is lost due to uplevel use append errMsg [formatErrStackTrace $::errorInfo $siteconfig {}] reportErrorAndExit $errMsg } if {$siteconfig eq [getConf siteconfig]} { set ::g_siteconfig_loaded 1 } else { set ::g_extra_siteconfig_loaded 1 } } # check on extra_siteconfig after initial siteconfig loaded in case # it inhibits this extra load if {$siteconfig eq [getConf siteconfig] && [getConf\ extra_siteconfig] ne {}} { lappend siteconfiglist [getConf extra_siteconfig] } } } # Used to tell if a machine is running Windows or not proc isWin {} { return [expr {$::tcl_platform(platform) eq {windows}}] } # Get default path separator proc getPathSeparator {} { if {![info exists ::g_def_separator]} { set ::g_def_separator [expr {[isWin] ? {;} : {:}}] } return $::g_def_separator } # Sub level separator to serialize a second level of info in env var set ::g_sub1_separator & # Sub sub level separator to serialize a third level of info in env var set ::g_sub2_separator | # Detect if terminal is attached to stderr message channel proc isStderrTty {} { if {![info exists ::g_is_stderr_tty]} { set ::g_is_stderr_tty [expr {![catch {fconfigure stderr -mode}]}] } return $::g_is_stderr_tty } # Provide columns number for output formatting proc getTtyColumns {} { if {![info exists ::g_tty_columns]} { # determine col number from tty capabilites # tty info query depends on running OS switch -- $::tcl_platform(os) { SunOS { catch {regexp {columns = (\d+);} [exec stty] match cols} errMsg } {Windows NT} { catch {regexp {Columns:\s+(\d+)} [exec mode] match cols} errMsg } default { catch {set cols [lindex [exec stty size] 1]} errMsg } } # default size if tty cols cannot be found set ::g_tty_columns [expr {![info exists cols] || $cols eq {0} ? 80 :\ $cols}] } return $::g_tty_columns } # Get force mode proc getForce {} { if {![info exists ::g_force]} { set force 0 ;# By-pass dependency consistency # overriden value coming the command-line if {[info exists ::asked_force]} { set force $::asked_force } set ::g_force $force reportDebug "force set to '$force'" } return $::g_force } # Initialize Select Graphic Rendition table proc initConfColors {envvar value validvallist intvallist} { # overriden value coming from environment if {[info exists ::env($envvar)]} { set colors_list $::env($envvar) if {[catch { # test overriden value could be set to a dummy array variable array set test_colors [split $colors_list {:=}] } errMsg ]} { # report issue as a debug message rather warning to avoid # disturbing user with a warning message in the middle of a # useful output as this table will be initialized at first use reportDebug "Ignore invalid value set in $envvar ($colors_list)" unset colors_list } } # if no valid override set use default color theme for terminal # background color kind (light or dark) if {![info exists colors_list]} { if {[getConf term_background] eq {light}} { set colors_list {hi=1:db=2:se=2:er=31:wa=33:me=35:in=34:mp=1;34:di=34:al=36:sy=35:de=4:cm=32} } else { set colors_list {hi=1:db=2:se=2:er=91:wa=93:me=95:in=94:mp=1;94:di=94:al=96:sy=95:de=4:cm=92} } if {[catch { array set test_colors [split $colors_list {:=}] } errMsg ]} { reportDebug "Ignore invalid default [getConf term_background]\ background colors ($colors_list)" # define an empty list if no valid value set set colors_list {} } } # check each color defined and unset invalid codes set value {} foreach {elt col} [split $colors_list {:=}] { if {![regexp {^[\d;]+$} $col]} { reportDebug "Ignore invalid color code for '$elt' ($col)" } else { lappend value $elt=$col } } set value [join $value :] # set SGR table as an array to easily access rendition for each key array unset ::g_colors array set ::g_colors [split $value {:=}] return $value } # Initialize color configuration value proc initConfColor {envvar value validvallist intvallist} { # overriden value coming from environment via standard variable # https://no-color.org/ and https://bixense.com/clicolors/ if {[info exists ::env(NO_COLOR)]} { set value never } elseif {[info exists ::env(CLICOLOR)]} { if {$::env(CLICOLOR) eq {0}} { set value never } else { set value auto } } elseif {[info exists ::env(CLICOLOR_FORCE)] && $::env(CLICOLOR_FORCE)\ ne {0}} { set value always } # overriden value coming from environment via Modules-specific variable if {$envvar ne {} && [info exists ::env($envvar)]} { # ignore non-valid values if {[llength $validvallist] == 0 || [isInList $validvallist\ $::env($envvar)]} { set value $::env($envvar) } } # overriden value coming the command-line if {[info exists ::asked_color]} { set value [set ::asked_color] } # convert value to its internal representation if {[llength $intvallist] > 0} { set value [lindex $intvallist [lsearch -exact $validvallist $value]] } # disable color mode if no terminal attached except if 'always' asked if {$value != 0 && (![isStderrTty] || $value == 2)} { incr value -1 } # initialize color theme if color mode enabled getConf colors return $value } # Is currently set verbosity level is equal or higher than level passed as arg proc isVerbosityLevel {name} { return [expr {[lsearch -exact [lindex $::g_config_defs(verbosity) 3]\ [getConf verbosity]] >= [lsearch -exact [lindex\ $::g_config_defs(verbosity) 3] $name]}] } # Is match performed in a case sensitive or insensitive manner proc isIcase {} { # depending on current sub-command, list values that equal to a case # insensitive match enablement lappend enabledValList always if {[isInList [list avail whatis search paths] [currentCommandName]]} { lappend enabledValList search } return [isInList $enabledValList [getConf icase]] } proc raiseErrorCount {} { incr ::error_count } proc renderFalse {} { reportDebug called. if {[info exists ::g_false_rendered]} { reportDebug {false already rendered} } elseif {[info exists ::g_shellType]} { # setup flag to render only once set ::g_false_rendered 1 # render a false value most of the time through a variable assignement # that will be looked at in the shell module function calling # modulecmd.tcl to return in turns a boolean status. Except for python # and cmake, the value assigned to variable is also returned as the # entire rendering status switch -- $::g_shellType { sh - csh - fish { # no need to set a variable on real shells as last statement # result can easily be checked puts stdout {test 0 = 1;} } tcl { puts stdout {set _mlstatus 0;} } cmd { puts stdout {set errorlevel=1} } perl { puts stdout {{ no strict 'vars'; $_mlstatus = 0; }} } python { puts stdout {_mlstatus = False} } ruby { puts stdout {_mlstatus = false} } lisp { puts stdout {nil} } cmake { puts stdout {set(_mlstatus FALSE)} } r { puts stdout {mlstatus <- FALSE} } } } } proc renderTrue {} { reportDebug called. # render a true value most of the time through a variable assignement that # will be looked at in the shell module function calling modulecmd.tcl to # return in turns a boolean status. Except for python and cmake, the # value assigned to variable is also returned as the full rendering status switch -- $::g_shellType { sh - csh - fish { # no need to set a variable on real shells as last statement # result can easily be checked puts stdout {test 0;} } tcl { puts stdout {set _mlstatus 1;} } cmd { puts stdout {set errorlevel=0} } perl { puts stdout {{ no strict 'vars'; $_mlstatus = 1; }} } python { puts stdout {_mlstatus = True} } ruby { puts stdout {_mlstatus = true} } lisp { puts stdout {t} } cmake { puts stdout {set(_mlstatus TRUE)} } r { puts stdout {mlstatus <- TRUE} } } } proc renderText {text} { reportDebug "called ($text)." # render a text value most of the time through a variable assignement that # will be looked at in the shell module function calling modulecmd.tcl to # return in turns a string value. switch -- $::g_shellType { sh - csh - fish { foreach word $text { # no need to set a variable on real shells, echoing text will make # it available as result puts stdout "echo '$word';" } } tcl { puts stdout "set _mlstatus \"$text\";" } cmd { foreach word $text { puts stdout "echo $word" } } perl { puts stdout "{ no strict 'vars'; \$_mlstatus = '$text'; }" } python { puts stdout "_mlstatus = '$text'" } ruby { puts stdout "_mlstatus = '$text'" } lisp { puts stdout "(message \"$text\")" } cmake { puts stdout "set(_mlstatus \"$text\")" } r { puts stdout "mlstatus <- '$text'" } } } # # Debug, Info, Warnings and Error message handling. # # save message when report is not currently initialized as we do not # know yet if debug mode is enabled or not proc reportDebug {message {showcaller 1}} { # display caller name as prefix set prefix [expr {$showcaller && [info level] > 1 ? "[lindex [info level\ -1] 0]: " : {}}] lappend ::errreport_buffer [list reportDebug $prefix$message 0] } # regular procedure to use once error report is initialized proc __reportDebug {message {showcaller 1}} { # display active interp details if not the main one set prefix [currentDebugMsgPrefix] # display caller name as prefix if {$showcaller && [info level] > 1} { append prefix "[lindex [info level -1] 0]: " } report [sgr db "DEBUG $prefix$message"] 0 1 } # alternative procedure used when debug is disabled proc __reportDebugNop {args} {} proc reportWarning {message {recordtop 0}} { reportError $message $recordtop WARNING wa 0 } proc reportError {message {recordtop 0} {severity ERROR} {sgrkey er}\ {raisecnt 1}} { lappend ::errreport_buffer [list reportError $message $recordtop $severity\ $sgrkey $raisecnt] } proc __reportError {message {recordtop 0} {severity ERROR} {sgrkey er}\ {raisecnt 1}} { # if report disabled, also disable error raise to get a coherent # behavior (if no message printed, no error code change) if {!$::g_inhibit_errreport} { if {$raisecnt} { raiseErrorCount } set msgsgr "[sgr $sgrkey $severity]: $message" # record message to report it later on if a record id is found if {[currentMsgRecordId] ne {}} { recordMessage $msgsgr $recordtop # skip message report if silent } elseif {[isVerbosityLevel concise]} { # save error messages to render them all together in JSON format if {[isReportFormat json]} { lappend ::g_report_erralist $severity $message } else { report $msgsgr 0 0 1 } } } } # throw known error (call error with 'known error' code) proc knerror {message {code MODULES_ERR_KNOWN}} { error $message {} $code } # save message if report is not yet initialized proc reportErrorAndExit {message} { lappend ::errreport_buffer [list reportErrorAndExit $message] } # regular procedure to use once error report is initialized proc __reportErrorAndExit {message} { raiseErrorCount renderFalse error $message {} MODULES_ERR_RENDERED } proc reportInternalBug {message {modfile {}}} { if {$modfile ne {}} { append message "\nIn '$modfile'" } append message "\nPlease contact <[getConf contact]>" reportError $message 0 {Module ERROR} me } proc reportInfo {message {title INFO}} { if {[isVerbosityLevel normal]} { # use reportError for conveniance but there is no error here reportError $message 0 $title in 0 } } # is currently active message record id at top level proc isMsgRecordIdTop {} { return [expr {[llength $::g_msgRecordIdStack] eq 1}] } # record messages on the eventual additional module evaluations that have # occurred during the current evaluation proc reportModuleEval {} { set evalid [currentEvalId] array set contexttitle {conun {Unloading conflict} reqlo {Loading\ requirement} depre {Reloading dependent} depun {Unloading dependent}\ urequn {Unloading useless requirement}} if {[info exists ::g_moduleEval($evalid)]} { foreach contextevallist $::g_moduleEval($evalid) { set modlist [lassign $contextevallist context] # skip context with no description title if {[info exists contexttitle($context)]} { reportInfo [join $modlist] $contexttitle($context) } } # purge list in case same evaluation is re-done afterward unset ::g_moduleEval($evalid) } } # render messages related to current record id under an header block proc reportMsgRecord {header} { set recid [currentMsgRecordId] if {[info exists ::g_msgRecord($recid)]} { # skip message report if silent if {[isVerbosityLevel concise]} { set tty_cols [getTtyColumns] set padding { } set dispmsg $header foreach msg $::g_msgRecord($recid) { # split lines if too large for terminal set first 1 set max_idx [expr {$tty_cols - [string length $padding]}] set linelist [list] foreach line [split $msg \n] { set lineadd {} while {$lineadd ne $line} { set line_max_idx $max_idx # sgr tags consume no length set eidx 0 while {[set sidx [string first "\033\[" $line $eidx]] !=\ -1} { set eidx [string first m $line $sidx] incr line_max_idx [expr {1 + $eidx - $sidx}] } # no split if no whitespace found to slice if {[string length $line] > $line_max_idx && [set cut_idx\ [string last { } $line $line_max_idx]] != -1} { set lineadd [string range $line 0 [expr {$cut_idx-1}]] set line [string range $line [expr {$cut_idx+1}] end] } else { set lineadd $line } lappend linelist $lineadd if {$first} { set first 0 incr max_idx -[string length $padding] } } } # display each line set first 1 foreach line $linelist { append dispmsg \n if {$first} { set first 0 } else { append dispmsg $padding } append dispmsg $padding$line } } reportSeparateNextContent report $dispmsg reportSeparateNextContent } # purge message list in case same evaluation is re-done afterward unset ::g_msgRecord($recid) # report header if no other specific msg to output in verbose mode or in # normal verbosity mode if currently processing a cmd which triggers # multiple module evaluations that cannot be guessed by the user } elseif {[isVerbosityLevel verbose] || ([isVerbosityLevel normal] && (\ [ongoingCommandName restore] || [ongoingCommandName source]))} { report $header } } # separate next content produced if any proc reportSeparateNextContent {} { lappend ::errreport_buffer [list reportSeparateNextContent] } # regular procedure to use once error report is initialized proc __reportSeparateNextContent {} { # hold or apply if {[isReportHeld]} { lappend ::g_holdReport([currentReportHoldId]) [list\ reportSeparateNextContent] } else { set ::g_report_sep_next 1 } } proc isReportFormat {format} { return [expr {$::g_report_format eq $format}] } # save message for block rendering proc recordMessage {message {recordtop 0}} { lappend ::g_msgRecord([expr {$recordtop ? [topMsgRecordId] :\ [currentMsgRecordId]}]) $message } # filter and format error stack trace to only report useful content proc formatErrStackTrace {errmsg loc {cmdlist {}}} { set headstr "\n while executing\n" set splitstr "\n invoked from within\n" set splitstrlen [string length $splitstr] set aftheadidx [string first $headstr $errmsg] if {$aftheadidx != -1} { incr aftheadidx [string length $headstr] } # get name of invalid command name to maintain it in error stack trace if {[string equal -length 22 {invalid command name "} $errmsg]} { set unkcmd [lindex [split [string range $errmsg 0 $aftheadidx] {"}] 1] } else { set unkcmd {} } # get list of modulecmd.tcl internal procedure to filter out from stack # skip this when no interp command list is provided if {[llength $cmdlist] > 0} { lassign [getDiffBetweenList [concat [info commands] [info procs]]\ $cmdlist] filtercmdlist keepcmdlist } else { set filtercmdlist {} } # define commands to filter out from bottom of stack set filtercmdendlist [list {eval $modcontent} "source $loc" {uplevel 1\ source $siteconfig}] # filter out modulecmd internal references at beginning of stack set internals 1 while {$internals && $aftheadidx != -1} { # fetch erroneous command and its caller set stackelt [string range $errmsg $aftheadidx [string first\ $splitstr $errmsg $aftheadidx]] lassign [split [lindex [split $stackelt {"}] 1]] cmd1 cmd2 set cmdcaller [lindex [split [string range $stackelt [string last\ {(procedure } $stackelt] end] {"}] 1] if {$cmd1 eq {eval}} { set cmd1 $cmd2 } # filter out stack element refering to or called by an unknown procedure # (ie. a modulecmd.tcl internal procedure) if {[string index $cmd1 0] ne {$} && $cmd1 ne $unkcmd && ([isInList\ $filtercmdlist $cmdcaller] || [isInList $filtercmdlist $cmd1])} { set errmsg [string replace $errmsg $aftheadidx [expr {[string first\ $splitstr $errmsg] + $splitstrlen - 1}]] } else { set internals 0 } } # filter out modulecmd internal references at end of stack set internals 1 while {$internals} { set beffootidx [string last $splitstr $errmsg] set stackelt [string range $errmsg $beffootidx end] set cmd [lindex [split $stackelt {"}] 1] if {[isInList $filtercmdendlist $cmd]} { set errmsg [string replace $errmsg $beffootidx end] } else { set internals 0 } } # replace error location at end of stack set lastnl [string last \n $errmsg] set lastline [string range $errmsg [expr {$lastnl + 1}] end] if {[string match { ("eval" body line*} $lastline]} { set errmsg [string replace $errmsg $lastnl [expr {$lastnl + [string\ length " (\"eval\" body line"]}] "\n (file \"$loc\" line"] } elseif {![string match { (file *} $lastline]} { # add error location at end of stack append errmsg "\n (file \"$loc\")" } return $errmsg } # Select Graphic Rendition of a string with passed sgr key (if color enabled) proc sgr {sgrkey str} { if {[getConf color] && [info exists ::g_colors($sgrkey)]} { set sgrset $::g_colors($sgrkey) # if render bold or faint just reset that attribute, not all if {$sgrset == 1 || $sgrset == 2} { set sgrreset 22 } else { set sgrreset 0 } set str "\033\[${sgrset}m$str\033\[${sgrreset}m" } return $str } # save message if report is not yet initialized proc report {message {nonewline 0} {immed 0} {padnl 0}} { lappend ::errreport_buffer [list report $message $nonewline $immed $padnl] } # regular procedure to use once error report is initialized proc __report {message {nonewline 0} {immed 0} {padnl 0}} { # hold or print output if {!$immed && [isReportHeld]} { lappend ::g_holdReport([currentReportHoldId]) [list report $message\ $nonewline $immed $padnl] } else { if {![info exists ::g_already_report]} { set ::g_already_report 1 # start pager at first call and only if enabled if {$::start_pager} { startPager } # startup content in case of structured output format if {[isReportFormat json]} { report \{ 1 } # produce blank line prior message if asked to } elseif {[info exists ::g_report_sep_next]} { unset ::g_report_sep_next report [expr {[isReportFormat json] ? {,} : {}}] } # prefix msg lines after first one with 2 spaces if {$padnl} { set first 1 foreach line [split $message \n] { if {$first} { set first 0 } else { append padmsg "\n " } append padmsg $line } set message $padmsg } # protect from issue with fd, just ignore it catch { if {$nonewline} { puts -nonewline $::reportfd $message } else { puts $::reportfd $message } } } } # report error the correct way depending of its type proc reportIssue {issuetype issuemsg {issuefile {}}} { switch -- $issuetype { invalid { reportInternalBug $issuemsg $issuefile } default { reportError $issuemsg } } } # report defined command (used in display evaluation mode) proc reportCmd {cmd args} { set extratab [expr {[string length $cmd] < 8 ? "\t" : {}}] # only brace empty arguments or those containing whitespace set cmdargs {} foreach cmdarg $args { if {$cmdargs ne {}} { append cmdargs { } } if {$cmdarg eq {} || [string first { } $cmdarg] > -1} { append cmdargs "{$cmdarg}" } else { append cmdargs $cmdarg } } report [sgr cm $cmd]$extratab\t$cmdargs # empty string returns if command result is another command input return {} } # report defined command (called as an execution trace) proc reportCmdTrace {cmdstring args} { eval reportCmd $cmdstring } proc reportVersion {} { report {Modules Release 4.5.2\ (2020-07-30)} } # disable error reporting (non-critical report only) unless debug enabled proc inhibitErrorReport {} { if {![isVerbosityLevel debug]} { set ::g_inhibit_errreport 1 } } proc reenableErrorReport {} { set ::g_inhibit_errreport 0 } proc isErrorReportInhibited {} { return $::g_inhibit_errreport } # init error report and output buffered messages proc initErrorReport {} { # ensure init is done only once if {![info exists ::g_init_error_report]} { set ::g_init_error_report 1 # determine message paging configuration and enablement initPager # ask for color init now as debug mode has already fire lines to render # and we want them to be reported first (not the color init lines) if {[isVerbosityLevel debug]} { getConf color } # replace report procedures used to bufferize messages until error # report being initialized by regular report procedures rename ::reportDebug {} if {[isVerbosityLevel debug]} { rename ::__reportDebug ::reportDebug } else { # set a disabled version if debug is disabled rename ::__reportDebugNop ::reportDebug } rename ::reportError {} rename ::__reportError ::reportError rename ::reportErrorAndExit {} rename ::__reportErrorAndExit ::reportErrorAndExit rename ::reportSeparateNextContent {} rename ::__reportSeparateNextContent ::reportSeparateNextContent rename ::report {} rename ::__report ::report # now error report is init output every message saved in buffer foreach errreport $::errreport_buffer { eval $errreport } } } # drop or report held messages proc releaseHeldReport {args} { foreach {holdid action} $args { if {[info exists ::g_holdReport($holdid)]} { if {$action eq {report}} { foreach repcall $::g_holdReport($holdid) { eval $repcall } } unset ::g_holdReport($holdid) } } } # exit in a clean manner by closing interaction with external components proc cleanupAndExit {code} { # finish output document if json format enabled if {[isReportFormat json]} { # render error messages all together if {[info exists ::g_report_erralist]} { # ignite report first to get eventual error message from report # initialization in order 'foreach' got all messages prior firing report "\"errors\": \[" 1 foreach {sev msg} $::g_report_erralist { # split message in lines lappend dispmsglist "\n{ \"severity\": \"$sev\", \"message\": \[\ \"[join [split [charEscaped $msg \"] \n] {", "}]\" \] }" } report "[join $dispmsglist ,] \]" } # inhibit next content separator if output is ending if {[info exists ::g_report_sep_next]} { unset ::g_report_sep_next } report \} } # close pager if enabled if {$::reportfd ne {stderr}} { catch {flush $::reportfd} catch {close $::reportfd} } exit $code } # init configuration for output paging to prepare for startup proc initPager {} { set pager [getConf pager] # empty or 'cat' pager command means no-pager set no_cmds [list {} cat] # default pager enablement depends on pager command value set ::use_pager [notInList $no_cmds [file tail [lindex $pager 0]]] set init_use_pager [notInList $no_cmds [file tail [lindex\ $::g_config_defs(pager) 1]]] # paging may have been enabled or disabled from the command-line if {[info exists ::asked_use_pager]} { # asked enablement could only nullify a previous asked disablement # as it requires a valid pager command configuration, which by default # enables pagination if {!$::asked_use_pager && $::use_pager} { set ::use_pager 0 } set asked $::asked_use_pager } else { set asked - } # some module command may also turn off pager if {$::command eq {clear} || ($::command eq {ml} && [lindex $::otherargv\ 0] eq {clear})} { set ::use_pager 0 } # start paging if enabled and if error stream is attached to a terminal set is_tty [isStderrTty] if {$is_tty && $::use_pager} { reportDebug "start pager (asked_use_pager=$asked, cmd='$pager')" set ::start_pager 1 } else { reportDebug "no pager start (is_tty=$is_tty, mod_cmd='$::command',\ use_pager=$::use_pager, asked_use_pager=$asked, cmd='$pager')" set ::start_pager 0 } } # start pager pipe process with defined configuration proc startPager {} { if {[catch { set ::reportfd [open "|[getConf pager] >@stderr 2>@stderr" w] fconfigure $::reportfd -buffering line -blocking 1 -buffersize 65536 } errMsg]} { reportWarning $errMsg } } # helper procedures to format various messages proc getHintUnFirstMsg {modlist} { return "HINT: Might try \"module unload [join $modlist]\" first." } proc getHintLoFirstMsg {modlist} { if {[llength $modlist] > 1} { set oneof {at least one of } set mod modules } else { set oneof {} set mod module } return "HINT: ${oneof}the following $mod must be loaded first: $modlist" } proc getErrConflictMsg {mod conlist} { return "$mod cannot be loaded due to a conflict.\n[getHintUnFirstMsg\ $conlist]" } proc getErrPrereqMsg {mod prelist {load 1}} { lassign [if {$load} {list {} missing [getHintLoFirstMsg $prelist]}\ {list un a [getHintUnFirstMsg $prelist]}] un mis hintmsg return "$mod cannot be ${un}loaded due to $mis prereq.\n$hintmsg" } proc getErrReqLoMsg {prelist} { return "Load of requirement '[join $prelist {' or '}]' failed" } proc getReqNotLoadedMsg {prelist} { return "Requirement '[join $prelist {' or '}]' is not loaded" } proc getDepLoadedMsg {prelist} { set is [expr {[llength $prelist] > 1 ? {are} : {is}}] return "Dependent '[join $prelist {' and '}]' $is loaded" } proc getErrConUnMsg {conlist} { return "Unload of conflicting '[join $conlist {' and '}]' failed" } proc getConIsLoadedMsg {conlist {loading 0}} { set is [expr {[llength $conlist] > 1 ? {are} : {is}}] set loaded [expr {$loading ? {loading} : {loaded}}] return "Conflicting '[join $conlist {' and '}]' $is $loaded" } ######################################################################## # Use a slave TCL interpreter to execute modulefiles # # dummy proc to disable modulefile commands on some evaluation modes proc nop {args} {} # dummy proc for commands available on other Modules flavor but not here proc nimp {cmd args} { reportWarning "'$cmd' command not implemented" } proc get-env {var {valifunset {}}} { # return current value if exists and not cleared if {[info exists ::env($var)] && ![info exists ::g_clearedEnvVars($var)]} { return $::env($var) } else { return $valifunset } } proc set-env {var val} { set mode [currentMode] reportDebug "$var=$val" interp-sync-env set $var $val # variable is not cleared anymore if set again if {[info exists ::g_clearedEnvVars($var)]} { unset ::g_clearedEnvVars($var) } # propagate variable setup to shell environment on load and unload mode if {$mode eq {load} || $mode eq {unload}} { set ::g_stateEnvVars($var) new } } proc reset-to-unset-env {var {val {}}} { interp-sync-env set $var $val # set var as cleared if val is empty if {$val eq {}} { set ::g_clearedEnvVars($var) 1 } } proc unset-env {var {internal 0} {val {}}} { set mode [currentMode] reportDebug "$var (internal=$internal, val=$val)" # clear value instead of unset it not to break variable later reference # in modulefile. clear whether variable set or not to get a later usage # consistent behavior whatever env is setup if {!$internal} { reset-to-unset-env $var $val # internal variables (like ref counter var) are purely unset if they exists } elseif {[info exists ::env($var)]} { interp-sync-env unset $var set intwasset 1 } # propagate deletion in any case if variable is public and for internal # one only if variable was set if {($mode eq {load} || $mode eq {unload}) && (!$internal ||\ [info exists intwasset])} { set ::g_stateEnvVars($var) del } } # synchronize environment variable change over all started sub interpreters proc interp-sync-env {op var {val {}}} { set envvar ::env($var) # apply operation to main interpreter switch -- $op { set { set $envvar $val } unset { unset $envvar } } # apply operation to each sub-interpreters if not found autosynced if {[llength [interp slaves]] > 0} { reportDebug "$op var='$envvar', val='$val' on interp(s) [interp slaves]" foreach itrp [interp slaves] { switch -- $op { set { # no value pre-check on Windows platform as an empty value set # means unsetting variable which lead querying value to error if {[isWin] || ![interp eval $itrp [list info exists $envvar]]\ || [interp eval $itrp [list set $envvar]] ne $val} { interp eval $itrp [list set $envvar $val] } } unset { if {[interp eval $itrp [list info exists $envvar]]} { interp eval $itrp [list unset $envvar] } } } } } } # Initialize list of interp alias commands to define for given evaluation mode proc initModfileModeAliases {mode aliasesVN aliasesPassArgVN tracesVN} { global g_modfilePerModeAliases upvar #0 $aliasesVN aliases upvar #0 $aliasesPassArgVN aliasesPassArg upvar #0 $tracesVN traces if {![info exists g_modfilePerModeAliases]} { set ::g_modfileBaseAliases [list getenv getenv is-loaded is-loaded\ is-saved is-saved is-used is-used is-avail is-avail uname uname\ module-info module-info exit exitModfileCmd reportCmdTrace\ reportCmdTrace reportInternalBug reportInternalBug reportWarning\ reportWarning reportError reportError raiseErrorCount\ raiseErrorCount report report isVerbosityLevel isVerbosityLevel\ isWin isWin puts putsModfileCmd readModuleContent readModuleContent\ formatErrStackTrace formatErrStackTrace] # list of alias commands whose target procedure is adapted according to # the evaluation mode set ::g_modfileEvalModes {load unload display help test whatis} array set g_modfilePerModeAliases { append-path {append-path remove-path append-path append-path append-path edit-path-wh } chdir {chdir nop reportCmd nop nop nop } conflict {conflict nop reportCmd nop nop nop } module {module module reportCmd nop nop nop } module-alias {module-alias module-alias module-alias module-alias module-alias module-alias } module-log {nimp nimp reportCmd nop nop nop } module-trace {nimp nimp reportCmd nop nop nop } module-user {nimp nimp reportCmd nop nop nop } module-verbosity {nimp nimp reportCmd nop nop nop } module-version {module-version module-version module-version module-version module-version module-version} module-virtual {module-virtual module-virtual module-virtual module-virtual module-virtual module-virtual} module-whatis {nop nop reportCmd nop nop module-whatis } prepend-path {prepend-path remove-path prepend-path prepend-path prepend-path edit-path-wh } prereq {prereq nop reportCmd nop nop nop } remove-path {remove-path remove-path-un remove-path remove-path remove-path edit-path-wh } set-alias {set-alias set-alias-un reportCmd nop nop nop } set-function {set-function set-function-un reportCmd nop nop nop } setenv {setenv setenv-un setenv setenv setenv setenv-wh } system {system system reportCmd nop nop nop } unset-alias {unset-alias nop reportCmd nop nop nop } unset-function {unset-function nop reportCmd nop nop nop } unsetenv {unsetenv unsetenv-un unsetenv unsetenv unsetenv setenv-wh } x-resource {x-resource x-resource reportCmd nop nop nop } } } # alias commands where interpreter ref should be passed as argument array set aliasesPassArg [list puts __itrp__] # initialize list with all commands not dependent of the evaluation mode array set aliases $::g_modfileBaseAliases # add alias commands whose target command vary depending on the eval mode set modeidx [lsearch -exact $::g_modfileEvalModes $mode] foreach alias [array names g_modfilePerModeAliases] { set aliastarget [set aliases($alias) [lindex\ $g_modfilePerModeAliases($alias) $modeidx]] # some target procedures need command name as first arg if {$aliastarget eq {reportCmd} || $aliastarget eq {nimp}} { set aliasesPassArg($alias) $alias # associate a trace command if per-mode alias command is not reportCmd # in display mode } elseif {$mode eq {display}} { set traces($alias) reportCmdTrace } } } proc execute-modulefile {modfile modname modspec {must_have_cookie 1}} { pushModuleFile $modfile pushModuleName $modname pushSpecifiedName $modspec set mode [currentMode] pushDebugMsgPrefix [getEvalModuleStackDepth] $mode $modname # skip modulefile if interpretation has been inhibited if {$::g_inhibit_interp} { reportDebug "skipping $modfile" return 1 } reportDebug "sourcing $modfile" if {![info exists ::g_modfileUntrackVars]} { # list variable that should not be tracked for saving array set ::g_modfileUntrackVars [list ModulesCurrentModulefile 1\ must_have_cookie 1 modcontent 1 env 1] # commands that should be renamed before aliases setup array set ::g_modfileRenameCmds [list puts _puts] } # dedicate an interpreter per mode and per level of interpretation to have # a dedicated interpreter in case of cascaded multi-mode interpretations set itrp __modfile_${mode}_[getEvalModuleStackDepth] # evaluation mode-specific configuration set dumpCommandsVN g_modfile${mode}Commands set aliasesVN g_modfile${mode}Aliases set aliasesPassArgVN g_modfile${mode}AliasesPassArg set tracesVN g_modfile${mode}Traces if {![info exists ::$aliasesVN]} { initModfileModeAliases $mode $aliasesVN $aliasesPassArgVN $tracesVN } # create modulefile interpreter at first interpretation if {![interp exists $itrp]} { reportDebug "creating interp $itrp" interp create $itrp # dump initial interpreter state to restore it before each modulefile # interpretation. use same dump state for all modes/levels if {![info exists ::g_modfileVars]} { dumpInterpState $itrp g_modfileVars g_modfileArrayVars\ g_modfileUntrackVars g_modfileProcs } # interp has just been created set fresh 1 } else { set fresh 0 } # reset interp state command before each interpretation resetInterpState $itrp $fresh g_modfileVars g_modfileArrayVars\ g_modfileUntrackVars g_modfileProcs $aliasesVN $aliasesPassArgVN\ $tracesVN g_modfileRenameCmds $dumpCommandsVN # reset modulefile-specific variable before each interpretation interp eval $itrp set ::ModulesCurrentModulefile "{$modfile}" interp eval $itrp set must_have_cookie $must_have_cookie set errorVal [interp eval $itrp { set modcontent [readModuleContent $::ModulesCurrentModulefile 1\ $must_have_cookie] if {$modcontent eq {}} { return 1 } info script $::ModulesCurrentModulefile # eval then call for specific proc depending mode under same catch set sourceFailed [catch { eval $modcontent switch -- [module-info mode] { help { if {[info procs ModulesHelp] eq {ModulesHelp}} { ModulesHelp } else { reportWarning "Unable to find ModulesHelp in\ $::ModulesCurrentModulefile." } } display { if {[info procs ModulesDisplay] eq {ModulesDisplay}} { ModulesDisplay } } test { if {[info procs ModulesTest] eq {ModulesTest}} { if {[string is true -strict [ModulesTest]]} { report {Test result: PASS} } else { report {Test result: FAIL} raiseErrorCount } } else { reportWarning "Unable to find ModulesTest in\ $::ModulesCurrentModulefile." } } } } errorMsg] if {$sourceFailed} { # no error in case of "continue" command # catch continue even if called outside of a loop if {$errorMsg eq {invoked "continue" outside of a loop}\ || $sourceFailed == 4} { unset errorMsg return 0 # catch break even if called outside of a loop } elseif {$errorMsg eq {invoked "break" outside of a loop}\ || ($errorMsg eq {} && (![info exists ::errorInfo]\ || $::errorInfo eq {}))} { unset errorMsg # report load/unload evaluation break if verbosity level >= normal if {([module-info mode load] || [module-info mode unload]) &&\ [isVerbosityLevel normal]} { reportError {Module evaluation aborted} } else { raiseErrorCount } return 1 } elseif {$errorCode eq {MODULES_ERR_SUBFAILED}} { # error counter and message already handled, just return error return 1 } elseif {$errorCode eq {MODULES_ERR_GLOBALTOP}} { reportError $errorMsg 1 return 1 } elseif {$errorCode eq {MODULES_ERR_GLOBAL}} { reportError $errorMsg return 1 } else { # format stack trace to report modulefile information only reportInternalBug [formatErrStackTrace $::errorInfo\ $::ModulesCurrentModulefile [concat [info procs] [info\ commands]]] return 1 } } else { unset errorMsg return 0 } }] reportDebug "exiting $modfile" popDebugMsgPrefix popSpecifiedName popModuleName popModuleFile return $errorVal } # Smaller subset than main module load... This function runs modulerc and # .version files proc execute-modulerc {modfile modname modspec} { pushModuleFile $modfile # push name to be found by module-alias and version pushModuleName $modname pushSpecifiedName $modspec set ::ModulesVersion {} pushDebugMsgPrefix [getEvalModuleStackDepth] $modname if {![info exists ::g_modrcUntrackVars]} { # list variable that should not be tracked for saving array set ::g_modrcUntrackVars [list ModulesCurrentModulefile 1\ ModulesVersion 1 modcontent 1 env 1] # commands that should be renamed before aliases setup array set ::g_modrcRenameCmds [list] # list interpreter alias commands to define array set ::g_modrcAliases [list uname uname system system chdir\ nop is-loaded is-loaded module-version module-version module-alias\ module-alias module-virtual module-virtual module nop module-info\ module-info module-trace nop module-verbosity nop module-user nop\ module-log nop reportInternalBug reportInternalBug setModulesVersion\ setModulesVersion readModuleContent readModuleContent\ formatErrStackTrace formatErrStackTrace] # alias commands where an argument should be passed array set ::g_modrcAliasesPassArg [list] # trace commands that should be associated to aliases array set ::g_modrcAliasesTraces [list] } # dedicate an interpreter per level of interpretation to have in case of # cascaded interpretations a specific interpreter per level set itrp __modrc_[getEvalModuleStackDepth] reportDebug "sourcing $modfile" # create modulerc interpreter at first interpretation if {![interp exists $itrp]} { reportDebug "creating interp $itrp" interp create $itrp # dump initial interpreter state to restore it before each modulerc # interpreation. use same dump state for all levels if {![info exists ::g_modrcVars]} { dumpInterpState $itrp g_modrcVars g_modrcArrayVars\ g_modrcUntrackVars g_modrcProcs } # interp has just been created set fresh 1 } else { set fresh 0 } # reset interp state command before each interpretation resetInterpState $itrp $fresh g_modrcVars g_modrcArrayVars\ g_modrcUntrackVars g_modrcProcs g_modrcAliases g_modrcAliasesPassArg\ g_modrcAliasesTraces g_modrcRenameCmds g_modrcCommands interp eval $itrp set ::ModulesCurrentModulefile "{$modfile}" interp eval $itrp {set ::ModulesVersion {}} set errorVal [interp eval $itrp { set modcontent [readModuleContent $::ModulesCurrentModulefile] if {$modcontent eq {}} { # simply skip rc file, no exit on error here return 1 } info script $::ModulesCurrentModulefile if [catch {eval $modcontent} errorMsg] { # format stack trace to report modulerc information only reportInternalBug [formatErrStackTrace $::errorInfo\ $::ModulesCurrentModulefile [concat [info procs] [info commands]]] return 1 } else { # pass ModulesVersion value to master interp if {[info exists ::ModulesVersion]} { setModulesVersion $::ModulesVersion } return 0 } }] # default version set via ModulesVersion variable in .version file # override previously defined default version for modname lassign [getModuleNameVersion] mod modname modversion if {$modversion eq {.version} && $::ModulesVersion ne {}} { # ModulesVersion should target an element in current directory if {[string first / $::ModulesVersion] == -1} { setModuleResolution $modname/default $modname/$::ModulesVersion\ default } else { reportError "Invalid ModulesVersion '$::ModulesVersion' defined" } } popDebugMsgPrefix popSpecifiedName popModuleName popModuleFile return $::ModulesVersion } # Save list of the defined procedure and the global variables with their # associated values set in slave interpreter passed as argument. Global # structures are used to save these information and the name of these # structures are provided as argument. proc dumpInterpState {itrp dumpVarsVN dumpArrayVarsVN untrackVarsVN\ dumpProcsVN} { upvar #0 $dumpVarsVN dumpVars upvar #0 $dumpArrayVarsVN dumpArrayVars upvar #0 $untrackVarsVN untrackVars upvar #0 $dumpProcsVN dumpProcs regexp {^__[a-z]+} $itrp itrpkind # save name and value for any other global variables foreach var [$itrp eval {info globals}] { if {![info exists untrackVars($var)]} { reportDebug "saving for $itrpkind var $var" if {[$itrp eval array exists ::$var]} { set dumpVars($var) [$itrp eval array get ::$var] set dumpArrayVars($var) 1 } else { set dumpVars($var) [$itrp eval set ::$var] } } } # save name of every defined procedures foreach var [$itrp eval {info procs}] { set dumpProcs($var) 1 } reportDebug "saving for $itrpkind proc list [array names dumpProcs]" } # Define commands to be known by slave interpreter. proc initInterpCommands {itrp fresh aliasesVN aliasesPassArgVN tracesVN\ renameCmdsVN} { upvar #0 $aliasesVN aliases upvar #0 $aliasesPassArgVN aliasesPassArg upvar #0 $tracesVN traces upvar #0 $renameCmdsVN renameCmds # rename some commands on freshly created interp before aliases defined # below overwrite them if {$fresh} { foreach cmd [array names renameCmds] { $itrp eval rename $cmd $renameCmds($cmd) } } # set interpreter alias commands each time to guaranty them being # defined and not overridden by modulefile or modulerc content foreach alias [array names aliases] { if {[info exists aliasesPassArg($alias)]} { set aliasarg $aliasesPassArg($alias) # pass current itrp reference on special keyword if {$aliasarg eq {__itrp__}} { set aliasarg $itrp } interp alias $itrp $alias {} $aliases($alias) $aliasarg } else { interp alias $itrp $alias {} $aliases($alias) } } foreach alias [array names traces] { interp eval $itrp [list trace add execution $alias leave\ $traces($alias)] } } # Restore initial setup of slave interpreter passed as argument based on # global structure previously filled with initial list of defined procedure # and values of global variable. proc resetInterpState {itrp fresh dumpVarsVN dumpArrayVarsVN untrackVarsVN\ dumpProcsVN aliasesVN aliasesPassArgVN tracesVN renameCmdsVN\ dumpCommandsVN} { upvar #0 $dumpVarsVN dumpVars upvar #0 $dumpArrayVarsVN dumpArrayVars upvar #0 $untrackVarsVN untrackVars upvar #0 $dumpProcsVN dumpProcs upvar #0 $dumpCommandsVN dumpCommands # look at list of defined procedures and delete those not part of the # initial state list. do not check if they have been altered as no vital # procedures lied there. note that if a Tcl command has been overridden # by a proc, it will be removed here and command will also disappear foreach var [$itrp eval {info procs}] { if {![info exists dumpProcs($var)]} { reportDebug "removing on $itrp proc $var" $itrp eval [list rename $var {}] } } # rename some commands and set aliases on interpreter initInterpCommands $itrp $fresh $aliasesVN $aliasesPassArgVN $tracesVN\ $renameCmdsVN # dump interpreter command list here on first time as aliases should be # set prior to be found on this list for correct match if {![info exists dumpCommands]} { set dumpCommands [$itrp eval {info commands}] reportDebug "saving for $itrp command list $dumpCommands" # if current interpreter command list does not match initial list it # means that at least one command has been altered so we need to recreate # interpreter to guaranty proper functioning } elseif {$dumpCommands ne [$itrp eval {info commands}]} { reportDebug "missing command(s), recreating interp $itrp" interp delete $itrp interp create $itrp initInterpCommands $itrp 1 $aliasesVN $aliasesPassArgVN $tracesVN\ $renameCmdsVN } # check every global variables currently set and correct them to restore # initial interpreter state. work on variables at the very end to ensure # procedures and commands are correctly defined foreach var [$itrp eval {info globals}] { if {![info exists untrackVars($var)]} { if {![info exists dumpVars($var)]} { reportDebug "removing on $itrp var $var" $itrp eval unset ::$var } elseif {![info exists dumpArrayVars($var)]} { if {$dumpVars($var) ne [$itrp eval set ::$var]} { reportDebug "restoring on $itrp var $var" if {[llength $dumpVars($var)] > 1} { # restore value as list $itrp eval set ::$var [list $dumpVars($var)] } else { # brace value to be able to restore empty string $itrp eval set ::$var "{$dumpVars($var)}" } } } else { if {$dumpVars($var) ne [$itrp eval array get ::$var]} { reportDebug "restoring on $itrp var $var" $itrp eval array set ::$var [list $dumpVars($var)] } } } } } ######################################################################## # commands run from inside a module file # proc module-info {what {more {}}} { set mode [currentMode] reportDebug "$what $more" switch -- $what { mode { if {$more ne {}} { set command [currentCommandName] return [expr {$mode eq $more || ($more eq {remove} && $mode eq \ {unload}) || ($more eq {switch} && $command eq {switch})}] } else { return $mode } } command { set command [currentCommandName] if {$more eq {}} { return $command } else { return [expr {$command eq $more}] } } name { return [currentModuleName] } specified { return [currentSpecifiedName] } shell { if {$more ne {}} { return [expr {$::g_shell eq $more}] } else { return $::g_shell } } flags { # C-version specific option, not relevant for Tcl-version but return # a zero integer value to avoid breaking modulefiles using it return 0 } shelltype { if {$more ne {}} { return [expr {$::g_shellType eq $more}] } else { return $::g_shellType } } user { # C-version specific option, not relevant for Tcl-version but return # an empty value or false to avoid breaking modulefiles using it if {$more ne {}} { return 0 } else { return {} } } alias { set ret [resolveModuleVersionOrAlias $more [isIcase]] if {$ret ne $more} { return $ret } else { return {} } } trace { return {} } tracepat { return {} } type { return Tcl } symbols { lassign [getModuleNameVersion $more 1] mod modname modversion set tag_list [getVersAliasList $mod] # if querying special symbol "default" but nothing found registered # on it, look at symbol registered on bare module name in case there # are symbols registered on it but no default symbol set yet to link # to them if {[llength $tag_list] == 0 && $modversion eq {default}} { set tag_list [getVersAliasList $modname] } return [join $tag_list :] } version { lassign [getModuleNameVersion $more 1] mod return [resolveModuleVersionOrAlias $mod [isIcase]] } loaded { lassign [getModuleNameVersion $more 1] mod return [getLoadedMatchingName $mod returnall] } default { knerror "module-info $what not supported" return {} } } } proc module-whatis {args} { set message [join $args] reportDebug $message lappend ::g_whatis $message return {} } # convert environment variable references in string to their values # every local variable is prefixed by '0' to ensure they will not be # overwritten through variable reference resolution process proc resolvStringWithEnv {0str} { # fetch variable references in string set 0match_list [regexp -all -inline {\$[{]?([A-Za-z_][A-Za-z0-9_]*)[}]?}\ ${0str}] if {[llength ${0match_list}] > 0} { # put in local scope every environment variable referred in string for {set 0i 1} {${0i} < [llength ${0match_list}]} {incr 0i 2} { set 0varname [lindex ${0match_list} ${0i}] if {![info exists ${0varname}]} { set ${0varname} [get-env ${0varname}] } } # resolv variable reference with values (now in local scope) set 0res [subst -nobackslashes -nocommands ${0str}] } else { set 0res ${0str} } reportDebug "'${0str}' resolved to '${0res}'" return ${0res} } # deduce modulepath from modulefile and module name proc getModulepathFromModuleName {modfile modname} { return [string range $modfile 0 end-[string length /$modname]] } # deduce module name from modulefile and modulepath proc getModuleNameFromModulepath {modfile modpath} { return [string range $modfile [string length $modpath/] end] } # extract module name from modulefile and currently enabled modulepaths proc findModuleNameFromModulefile {modfile} { set ret {} foreach modpath [getModulePathList] { if {[string first $modpath/ $modfile/] == 0} { set ret [getModuleNameFromModulepath $modfile $modpath] break } } return $ret } # extract modulepath from modulefile and currently enabled modulepaths proc findModulepathFromModulefile {modfile} { set ret {} foreach modpath [getModulePathList] { if {[string first $modpath/ $modfile/] == 0} { set ret $modpath break } } return $ret } # Determine with a name provided as argument the corresponding module name, # version and name/version. Module name is guessed from current module name # when shorthand version notation is used. Both name and version are guessed # from current module if name provided is empty. If 'name_relative_tocur' is # enabled then name argument may be interpreted as a name relative to the # current modulefile directory (useful for module-version and module-alias # for instance). proc getModuleNameVersion {{name {}} {name_relative_tocur 0}} { set curmod [currentModuleName] set curmodname [file dirname $curmod] set curmodversion [file tail $curmod] if {$name eq {}} { set name $curmodname set version $curmodversion # check for shorthand version notation like "/version" or "./version" # only if we are currently interpreting a modulefile or modulerc } elseif {$curmod ne {} && [regexp {^\.?\/(.*)$} $name match version]} { # if we cannot distinguish a module name, raise error when shorthand # version notation is used if {$::ModulesCurrentModulefile ne $curmod && $curmod ne {.modulerc}} { # name is the name of current module directory set name $curmodname } else { reportError "Invalid modulename '$name' found" return {} } } else { set name [string trimright $name /] set version [file tail $name] if {$name eq $version} { set version {} } else { set name [file dirname $name] } # name may correspond to last part of current module # if so name is replaced by current module name if {$name_relative_tocur && [file tail $curmodname] eq $name} { set name $curmodname } } if {$version eq {}} { set mod $name } else { set mod $name/$version } return [list $mod $name $version] } # Register alias or symbolic version deep resolution in a global array that # can be used thereafter to get in one query the actual modulefile behind # a virtual name. Also consolidate a global array that in the same manner # list all the symbols held by modulefiles. proc setModuleResolution {mod target {symver {}} {override_res_path 1}\ {auto_symver 0}} { global g_moduleResolved g_resolvedHash g_resolvedPath g_symbolHash # find end-point module and register step-by-step path to get to it set res $target lappend res_path $res while {$mod ne $res && [info exists g_resolvedPath($res)]} { set res $g_resolvedPath($res) lappend res_path $res } # error if resolution end on initial module if {$mod eq $res} { reportError "Resolution loop on '$res' detected" return 0 } # module name will be useful when registering symbol if {$symver ne {}} { lassign [getModuleNameVersion $mod] modfull modname } # change default symbol owner if previously given; auto symbol are defined # only if no default is pre-existing if {$symver eq {default} && !$auto_symver} { # alternative name "modname" is set when mod = "modname/default" both # names will be registered to be known for queries and resolution defs set modalt $modname if {[info exists g_moduleResolved($mod)]} { set prev $g_moduleResolved($mod) # there may not be a default in case of auto symbol if {[info exists g_symbolHash($prev)] && [set idx [lsearch -exact\ $g_symbolHash($prev) default]] != -1} { reportDebug "remove symbol 'default' from '$prev'" set g_symbolHash($prev) [lreplace $g_symbolHash($prev) $idx $idx] } } } # register end-point resolution reportDebug "$mod resolved to $res" set g_moduleResolved($mod) $res # set first element of resolution path only if not already set or # scratching enabled, no change when propagating symbol along res path if {$override_res_path || ![info exists g_resolvedPath($mod)]} { set g_resolvedPath($mod) $target } lappend g_resolvedHash($res) $mod # also register resolution on alternative name if any if {[info exists modalt]} { reportDebug "$modalt resolved to $res" set g_moduleResolved($modalt) $res if {$override_res_path || ![info exists g_resolvedPath($modalt)]} { set g_resolvedPath($modalt) $target } lappend g_resolvedHash($res) $modalt # register name alternative to know their existence set ::g_moduleAltName($modalt) $mod set ::g_moduleAltName($mod) $modalt } # if other modules were pointing to this one, adapt resolution end-point set relmod_list {} if {[info exists g_resolvedHash($mod)]} { set relmod_list $g_resolvedHash($mod) unset g_resolvedHash($mod) } # also adapt resolution for modules pointing to the alternative name if {[info exists modalt] && [info exists g_resolvedHash($modalt)]} { set relmod_list [concat $relmod_list $g_resolvedHash($modalt)] unset g_resolvedHash($modalt) } foreach relmod $relmod_list { set g_moduleResolved($relmod) $res reportDebug "$relmod now resolved to $res" lappend g_resolvedHash($res) $relmod } # register and propagate symbols to the resolution path, execption made for # auto symbol which are stored separately and not propagated if {[info exists g_symbolHash($mod)]} { set sym_list $g_symbolHash($mod) } else { set sym_list {} } if {$symver ne {} && $auto_symver} { reportDebug "define auto symbolic version '$mod' targeting $target" set ::g_autoSymbol($mod) $target } elseif {$symver ne {} && !$auto_symver} { # merge symbol definitions in case of alternative name if {[info exists modalt] && [info exists g_symbolHash($modalt)]} { set sym_list [lsort -dictionary -unique [concat $sym_list\ $g_symbolHash($modalt)]] reportDebug "set symbols '$sym_list' to $mod and $modalt" set g_symbolHash($mod) $sym_list set g_symbolHash($modalt) $sym_list } # dictionary-sort symbols and remove eventual duplicates set sym_list [lsort -dictionary -unique [concat $sym_list\ [list $symver]]] # propagate symbols in g_symbolHash and g_moduleVersion toward the # resolution path, handle that locally if we still work on same # modulename, call for a proper resolution as soon as we change of # module to get this new resolution registered foreach modres $res_path { lassign [getModuleNameVersion $modres] modfull modresname if {$modname eq $modresname} { if {[info exists g_symbolHash($modres)]} { set modres_sym_list [lsort -dictionary -unique [concat\ $g_symbolHash($modres) $sym_list]] } else { set modres_sym_list $sym_list } # sync symbols of alternative name if any if {[info exists ::g_moduleAltName($modres)]} { set altmodres $::g_moduleAltName($modres) reportDebug "set symbols '$modres_sym_list' to $modres and\ $altmodres" set g_symbolHash($altmodres) $modres_sym_list } else { reportDebug "set symbols '$modres_sym_list' to $modres" } set g_symbolHash($modres) $modres_sym_list # register symbolic version for querying in g_moduleVersion foreach symelt $sym_list { set modvers $modresname/$symelt reportDebug "module-version $modvers = $modres" set ::g_moduleVersion($modvers) $modres set ::g_sourceVersion($modvers) $::ModulesCurrentModulefile } # as we change of module name a proper resolution call should be # made (see below) and will handle the rest of the resolution path } else { set need_set_res 1 break } } # when registering an alias, existing symbols on alias source name should # be broadcast along the resolution path with a proper resolution call # (see below) } else { lassign [getModuleNameVersion $target] modres modresname set need_set_res 1 } # resolution needed to broadcast symbols along resolution path without # altering initial path already set for these symbols if {[info exists need_set_res]} { foreach symelt $sym_list { set modvers $modresname/$symelt reportDebug "set resolution for $modvers" setModuleResolution $modvers $modres $symelt 0 } } return 1 } # retrieve all names that resolve to passed mod proc getAllModuleResolvedName {mod {flag_autosym 0}} { set namelist {} set resmodlist {} set icase [isIcase] defineModEqProc $icase [getConf extended_default] # get parent directories of mod foreach modelt [split $mod /] { if {[info exists modroot]} { append modroot / } append modroot $modelt lappend resmodlist $modroot } # add additionnaly all the altnames set on directories, parents of mod # or on distant directories whose default version resolves to mod for {set i 0} {$i < [llength $resmodlist]} {incr i 1} { set modelt [getArrayKey ::g_resolvedHash [lindex $resmodlist $i] $icase] if {[info exists ::g_resolvedHash($modelt)]} { foreach resmod $::g_resolvedHash($modelt) { # if modelt is not a parent directory of mod, check its resolution # points to mod (directly for alias/sym or indirectly for dir # whose default version bridge resolution toward mod) if {[modEq $modelt $mod eqstart] || $::g_moduleResolved($resmod)\ eq $mod || [lindex [getPathToModule\ $::g_moduleResolved($resmod) {} 0] 1] eq $mod} { # prefix automatically generated symbols with 'as|' if asked if {$flag_autosym && [info exists ::g_autoSymbol($resmod)]} { appendNoDupToList namelist as|$resmod } else { appendNoDupToList namelist $resmod } unset modroot foreach reselt [split [file dirname $resmod] /] { if {[info exists modroot]} { append modroot / } append modroot $reselt appendNoDupToList resmodlist $modroot } } } } } return $namelist } # Specifies a default or alias version for a module that points to an # existing module version Note that aliases defaults are stored by the # short module name (not the full path) so aliases and defaults from one # directory will apply to modules of the same name found in other # directories. proc module-version {args} { reportDebug $args lassign [getModuleNameVersion [lindex $args 0] 1] mod modname modversion # go for registration only if valid modulename if {$mod ne {}} { foreach version [lrange $args 1 end] { set aliasversion $modname/$version # do not alter a previously defined alias version if {![info exists ::g_moduleVersion($aliasversion)]} { setModuleResolution $aliasversion $mod $version } else { reportWarning "Symbolic version '$aliasversion' already defined" } } } return {} } proc module-alias {args} { lassign [getModuleNameVersion [lindex $args 0]] alias lassign [getModuleNameVersion [lindex $args 1] 1] mod reportDebug "$alias = $mod" if {[setModuleResolution $alias $mod]} { set ::g_moduleAlias($alias) $mod set ::g_sourceAlias($alias) $::ModulesCurrentModulefile } return {} } proc module-virtual {args} { lassign [getModuleNameVersion [lindex $args 0]] mod set modfile [getAbsolutePath [lindex $args 1]] reportDebug "$mod = $modfile" set ::g_moduleVirtual($mod) $modfile set ::g_sourceVirtual($mod) $::ModulesCurrentModulefile return {} } proc module {command args} { set mode [currentMode] reportDebug "cmd='$command', args='$args'" # guess if called from top level set topcall [expr {[getEvalModuleStackDepth] == 0}] set tryhelpmsg [expr {$topcall ? "\nTry 'module --help' for more\ information." : {}}] if {$topcall} { set msgprefix {} } else { set msgprefix {module: } } # resolve and check command name lassign [parseModuleCommandName $command help] command cmdvalid cmdempty # clear other args if no command name supplied if {$cmdempty} { set args {} } # raise error if supplied command is not known if {!$cmdvalid} { knerror "${msgprefix}Invalid command '$command'$tryhelpmsg" } # parse options, do that globally to ignore options not related to a given # module sub-command (exclude them from arg list) lassign [eval parseModuleCommandArgs $command $args] show_oneperline\ show_mtime show_filter search_filter search_match dump_state args # parse module version specification if {[isInList [list avail paths whatis load unload switch help test\ display path is-avail] $command]} { set args [eval parseModuleVersionSpecifier 0 $args] } if {!$topcall} { # some commands can only be called from top level, not within modulefile switch -- $command { path - paths - autoinit - help - prepend-path - append-path -\ remove-path - is-loaded - is-saved - is-used - is-avail -\ info-loaded - clear { knerror "${msgprefix}Command '$command' not supported$tryhelpmsg" } } # other commands can only be called from modulefile evaluated from # command acting as top-level context (source and autoinit) if {([getEvalModuleStackDepth] > 1 || [notInList [list source autoinit]\ [currentCommandName]]) && $command eq {config}} { knerror "${msgprefix}Command '$command' not supported$tryhelpmsg" } } # argument number check switch -- $command { unload - source - display - initadd - initprepend - initrm - test -\ is-avail { if {[llength $args] == 0} { set argnberr 1 } } reload - aliases - list - purge - savelist - initlist - initclear -\ autoinit { if {[llength $args] != 0} { set argnberr 1 } } switch { if {[llength $args] == 0 || [llength $args] > 2} { set argnberr 1 } } path - paths - info-loaded { if {[llength $args] != 1} { set argnberr 1 } } search - save - restore - saverm - saveshow - clear { if {[llength $args] > 1} { set argnberr 1 } } initswitch { if {[llength $args] != 2} { set argnberr 1 } } prepend-path - append-path - remove-path { if {[llength $args] < 2} { set argnberr 1 } } config { if {[llength $args] > 2} { set argnberr 1 } } } if {[info exists argnberr]} { knerror "Unexpected number of args for '$command' command$tryhelpmsg" } # define if modfile should always be fully read even for validity check pushAlwaysReadFullFile [expr {[isInList [list path paths list avail\ aliases] $command]} ? 0 : 1] pushCommandName $command if {$topcall} { # Find and execute any global rc file found runModulerc } switch -- $command { load { # ignore flag used in collection to track non-user asked state set args [replaceFromList $args --notuasked] # no error raised on empty argument list to cope with # initadd command that may expect this behavior if {[llength $args] > 0} { set ret 0 # if top command is source, consider module load commands made # within sourced file evaluation as top load command if {$topcall || ([getEvalModuleStackDepth] == 1 && ( [aboveCommandName] eq {source} || [aboveCommandName] eq\ {autoinit}))} { set ret [eval cmdModuleLoad load 1 $args] } elseif {$mode eq {load}} { # load here if no auto mode, done through prereq elsewhere # inhibited if currently in DepRe context if {![getConf auto_handling] && [currentModuleEvalContext] ne\ {depre}} { # attempt load of not already loaded modules foreach arg $args { if {![is-loaded $arg] && ![is-loading $arg]} { lappend modlist $arg } } if {[info exists modlist]} { set ret [eval cmdModuleLoad reqlo 0 $modlist] # ignore obtained error if force mode enabled if {[getForce]} { set ret 0 } } } # register modulefiles to load as individual prereqs foreach arg $args { prereq $arg } # mods unload is handled via UReqUn mechanism when auto enabled # also unloads are triggered by ongoing reload, purge or # restore commands } elseif {![getConf auto_handling] && [notInList [list purge\ reload restore] [aboveCommandName]]} { # on unload mode, unload mods in reverse order, if loaded # prior this mod, if not user asked and not required by # other loaded mods set modlist [getLoadedModuleList] set modidx [lsearch -exact $modlist [currentModuleName]] if {$modidx != 0} { set priormodlist [lrange $modlist 0 $modidx] foreach arg [lreverse $args] { if {[set unmod [getLoadedMatchingName $arg {} 0\ $priormodlist]] ne {}} { if {[cmdModuleUnload urequn match 1 0 1 1 $unmod]} { reportWarning "Unload of useless requirement\ $unmod failed" 1 } } } } } # sub-module interpretation failed, raise error if {$ret && !$topcall} { knerror {} MODULES_ERR_SUBFAILED } } } unload { # if top command is source, consider module load commands made # within sourced file evaluation as top load command if {$topcall || ([getEvalModuleStackDepth] == 1 && ( [aboveCommandName] eq {source} || [aboveCommandName] eq\ {autoinit}))} { set ret [eval cmdModuleUnload unload match 1 0 0 0 $args] } elseif {$mode eq {load}} { # unload mods only on load mode, nothing done on unload mode as # the registered conflict guarantees the target module cannot # be loaded unless forced # do not unload module required by others even in force mode set ret [eval cmdModuleUnload conun match 0 0 0 1 $args] # register modulefiles to unload as individual conflicts foreach arg $args { # do not break on error yet, go through the whole modfile # evaluation in case conflict is solved later on catch {conflict $arg} } # sub-module interpretation failed, raise error if {$ret} { knerror {} MODULES_ERR_SUBFAILED } } } reload { cmdModuleReload } use { if {$topcall || $mode eq {load}} { eval cmdModuleUse $args } else { eval cmdModuleUnuse $args } } unuse { eval cmdModuleUnuse $args } source { if {$topcall || $mode eq {load}} { eval cmdModuleSource $args } else { # on unload mode, unsource script in reverse order eval cmdModuleUnsource [lreverse $args] } } switch { # pass 'user asked state' to switch procedure set uasked [expr {$topcall || ([getEvalModuleStackDepth] == 1 &&\ ([aboveCommandName] eq {source} || [aboveCommandName] eq\ {autoinit}))}] if {$uasked} { eval cmdModuleSwitch $uasked $args } else { # CAUTION: it is not recommended to use the `switch` # sub-command in modulefiles as this command is intended for # the command-line for a 2in1 operation. Could be removed from # the modulefile scope in a future release. Use `module unload` # and `module load` commands in modulefiles instead. switch -- $mode { load { eval cmdModuleSwitch $uasked $args } unload { # find what has been asked for unload and load lassign $args swunmod swlomod if {$swlomod eq {} && $swunmod ne {}} { set swlomod $swunmod } # apply same mechanisms than for 'module load' and # 'module unload' for an unload evaluation: nothing done # for switched-off module and unload of switched-on # module. If auto handling is enabled switched-on module # is handled via UReqUn mechanism. Also unloads are # triggered by ongoing reload, purge or restore commands if {![getConf auto_handling] && $swlomod ne {} &&\ [notInList [list purge reload restore]\ [aboveCommandName]]} { # unload mod if it was loaded prior this mod, not user # asked and not required by another loaded module set modlist [getLoadedModuleList] set modidx [lsearch -exact $modlist [currentModuleName]] if {$modidx != 0} { set priormodlist [lrange $modlist 0 $modidx] if {[set unmod [getLoadedMatchingName $swlomod {} 0\ $priormodlist]] ne {}} { if {[cmdModuleUnload urequn match 1 0 1 1 $unmod]} { reportWarning "Unload of useless requirement\ $unmod failed" 1 } } } } } } } } display { eval cmdModuleDisplay $args } avail { eval cmdModuleAvail $show_oneperline $show_mtime "{$show_filter}"\ "{$search_filter}" "{$search_match}" $args } aliases { cmdModuleAliases } path { eval cmdModulePath $args } paths { eval cmdModulePaths $args } list { cmdModuleList $show_oneperline $show_mtime } whatis { if {$args ne {}} { foreach arg $args { cmdModuleWhatIs $arg } } else { cmdModuleWhatIs } } search { eval cmdModuleApropos $args } purge { eval cmdModulePurge } save { eval cmdModuleSave $args } restore { eval cmdModuleRestore $args } saverm { eval cmdModuleSaverm $args } saveshow { eval cmdModuleSaveshow $args } savelist { cmdModuleSavelist $show_oneperline $show_mtime } initadd { eval cmdModuleInit add $args } initprepend { eval cmdModuleInit prepend $args } initswitch { eval cmdModuleInit switch $args } initrm { eval cmdModuleInit rm $args } initlist { eval cmdModuleInit list $args } initclear { eval cmdModuleInit clear $args } autoinit { cmdModuleAutoinit } clear { # ensure empty string is correctly passed eval cmdModuleClear "{$args}" } config { eval cmdModuleConfig $dump_state $args } help { eval cmdModuleHelp $args } test { eval cmdModuleTest $args } prepend-path - append-path - remove-path - is-loaded - is-saved -\ is-used - is-avail { eval cmdModuleResurface $command $args } info-loaded { eval cmdModuleResurface module-info loaded $args } } popCommandName popAlwaysReadFullFile # if called from top level render settings if any if {$topcall} { renderSettings } return {} } proc ml {args} { # ml cannot be called within modulefile, top level only if {[getEvalModuleStackDepth] > 0} { knerror {Command 'ml' not supported} } # filter out all known options from argument list to guess command name # without them in the way lassign [eval parseModuleCommandArgs ml $args] show_oneperline\ show_mtime show_filter search_filter search_match dump_state fargs # determine if first argument is a known module sub-command lassign [parseModuleCommandName [lindex $fargs 0] list] command cmdvalid\ cmdempty if {$cmdempty} { # consider empty string supplied as first argument as module name if {[llength $fargs] > 0} { set cmdvalid 0 } set margs $args } else { # first argument was command name set margs [lrange $args 1 end] } # directly call module procedure if sub-command spotted as first argument # or no argument supplied if {$cmdvalid} { eval module $command $margs } else { # no need to look for option arguments as they have already been parsed # in main procedure (error has already been raised for badly written # argument like '-' or '--') # parse specified module and get list of mods to unload and mods to load lassign [eval parseModuleVersionSpecifier 1 $fargs] modunlist modlolist # define if modfile should always be fully read even for validity check pushAlwaysReadFullFile 1 pushCommandName ml # Find and execute any global rc file found runModulerc set ret 0 pushSettings # first unload specified modules if {[llength $modunlist] > 0} { set ret [eval cmdModuleUnload unload match 1 0 0 0 $modunlist] } # then load other modules unless unload phase failed if {!$ret && [llength $modlolist] > 0} { set ret [eval cmdModuleLoad load 1 $modlolist] } # rollback changes if any load or unload failed if {$ret} { restoreSettings } popSettings popCommandName popAlwaysReadFullFile renderSettings } return {} } proc getModshareVarName {var} { # specific modshare variable for DYLD-related variables as a suffixed # variable will lead to warning messages with this tool if {[string range $var 0 4] eq {DYLD_}} { return MODULES_MODSHARE_${var} } else { return ${var}_modshare } } proc setenv {var val} { reportDebug "var='$var', val='$val'" # clean any previously defined reference counter array unset-env [getModshareVarName $var] 1 # Set the variable for later use during the modulefile evaluation set-env $var $val return {} } # undo setenv in unload mode proc setenv-un {var val} { reportDebug "var='$var', val='$val'" # clean any existing reference counter array unset-env [getModshareVarName $var] 1 # Add variable to the list of variable to unset in shell output code but # set it in interp context as done on load mode for later use during the # modulefile evaluation unset-env $var 0 $val return {} } # optimized setenv/unsetenv for whatis mode: init env variable with an empty # value if undefined. do not care about value, just avoid variable to be # undefined for later use during the modulefile evaluation proc setenv-wh {var args} { if {![info exists ::env($var)]} { reportDebug "var='$var', val=''" set ::env($var) {} } return {} } proc getenv {var {valifundef _UNDEFINED_}} { reportDebug "var='$var', valifundef='$valifundef'" if {[currentMode] ne {display}} { return [get-env $var $valifundef] } else { return "\$$var" } } proc unsetenv {var {val {}}} { reportDebug "var='$var', val='$val'" # clean any existing reference counter array unset-env [getModshareVarName $var] 1 # Set the variable for later use during the modulefile evaluation unset-env $var return {} } # undo unsetenv in unload mode proc unsetenv-un {var {val {}}} { if {$val ne {}} { return [setenv $var $val] } else { return [unsetenv $var] } } proc chdir {dir} { reportDebug $dir if {[file exists $dir] && [file isdirectory $dir]} { set ::g_changeDir $dir } else { # report issue but does not treat it as an error to have the # same behavior as C-version reportWarning "Cannot chdir to '$dir' for '[currentModuleName]'" } return {} } # superseed exit command to handle it if called within a modulefile # rather than exiting the whole process proc exitModfileCmd {{code 0}} { set mode [currentMode] reportDebug ($code) if {$mode eq {load}} { reportDebug {Inhibit next modulefile interpretations} set ::g_inhibit_interp 1 } # break to gently end interpretation of current modulefile return -code break } # enables slave interp to return ModulesVersion value to the master interp proc setModulesVersion {val} { set ::ModulesVersion $val } # supersede puts command to catch content sent to stdout/stderr within # modulefile in order to correctly send stderr content (if a pager has been # enabled) or postpone content channel send after rendering on stdout the # relative environment changes required by the modulefile proc putsModfileCmd {itrp args} { reportDebug "$args (itrp=$itrp)" # determine if puts call targets the stdout or stderr channel switch -- [llength $args] { 1 { set deferPuts 1 } 2 { switch -- [lindex $args 0] { -nonewline - stdout { set deferPuts 1 } stderr { set reportArgs [list [lindex $args 1]] } } } 3 { if {[lindex $args 0] eq {-nonewline}} { switch -- [lindex $args 1] { stdout { set deferPuts 1 } stderr { set reportArgs [list [lindex $args 2] 1] } } } else { set wrongNumArgs 1 } } default { set wrongNumArgs 1 } } # raise error if bad argument number detected, do this here rather in _puts # not to confuse people with an error reported by an internal name (_puts) if {[info exists wrongNumArgs]} { knerror {wrong # args: should be "puts ?-nonewline? ?channelId? string"} # defer puts if it targets stdout (see renderSettings) } elseif {[info exists deferPuts]} { lappend ::g_stdoutPuts $args # if it targets stderr call report, which knows what channel to use } elseif {[info exists reportArgs]} { # report message only if not silent if {[isVerbosityLevel concise]} { eval report $reportArgs } # pass to real puts command if not related to stdout and do that in modfile # interpreter context to get access to eventual specific channel } else { # re-throw error as a known error for accurate stack trace print if {[catch {$itrp eval _puts $args} errMsg]} { knerror $errMsg MODULES_ERR_CUSTOM } } } ######################################################################## # path fiddling # proc getReferenceCountArray {var separator} { # get reference counter set in environment set sharevar [getModshareVarName $var] array set refcount {} if {[info exists ::env($sharevar)]} { set modsharelist [psplit $::env($sharevar) [getPathSeparator]] # ignore environment ref count variable if malformed if {([llength $modsharelist] % 2) == 0} { array set refcount $modsharelist } else { reportDebug "Reference counter value in '$sharevar' is malformed\ ($modsharelist)" } } array set countarr {} if {[info exists ::env($var)]} { # do not skip a bare empty path entry that can also be found in # reference counter array (sometimes var is cleared by setting it # empty not unsetting it, ignore var in this case) if {$::env($var) eq {} && [info exists refcount()]} { lappend eltlist {} } else { set eltlist [split $::env($var) $separator] } # just go thought the elements of the variable, which means additional # elements part of the reference counter variable will be ignored foreach elt $eltlist { # no reference counter, means value has been set once if {![info exists refcount($elt)]} { set count 1 # bad reference counter value is ignored } elseif {![string is digit -strict $refcount($elt)]} { reportDebug "Reference counter value for '$elt' in '$sharevar' is\ erroneous ($refcount($elt))" set count 1 } else { set count $refcount($elt) } set countarr($elt) $count } } set count_list [array get countarr] reportDebug "(var=$var, delim=$separator) got '$count_list'" return $count_list } proc unload-path {args} { reportDebug ($args) lassign [eval parsePathCommandArgs unload-path $args] separator\ allow_dup idx_val var path_list array set countarr [getReferenceCountArray $var $separator] # Don't worry about dealing with this variable if it is already scheduled # for deletion if {[info exists ::g_stateEnvVars($var)] && $::g_stateEnvVars($var) eq\ {del}} { return {} } # save initial variable content to match index arguments set dir_list [split [get-env $var] $separator] # detect if empty env value means empty path entry if {[llength $dir_list] == 0 && [info exists countarr()]} { lappend dir_list {} } # build list of index to remove from variable set del_idx_list [list] foreach dir $path_list { # retrieve dir value if working on an index list if {$idx_val} { set idx $dir # go to next index if this one is not part of the existing range # needed to distinguish an empty value to an out-of-bound value if {$idx < 0 || $idx >= [llength $dir_list]} { continue } else { set dir [lindex $dir_list $idx] } } # update reference counter array if {[info exists countarr($dir)]} { incr countarr($dir) -1 set newcount $countarr($dir) if {$countarr($dir) <= 0} { unset countarr($dir) } } else { set newcount 0 } # get all entry indexes corresponding to dir set found_idx_list [lsearch -all -exact $dir_list $dir] # remove all found entries if {$newcount <= 0} { # only remove passed position in --index mode if {$idx_val} { lappend del_idx_list $idx } else { set del_idx_list [concat $del_idx_list $found_idx_list] } # if multiple entries found remove the extra entries compared to new # reference counter } elseif {[llength $found_idx_list] > $newcount} { # only remove passed position in --index mode if {$idx_val} { lappend del_idx_list $idx } else { # delete extra entries, starting from end of the list (on a path # variable, entries at the end have less priority than those at # the start) set del_idx_list [concat $del_idx_list [lrange $found_idx_list\ $newcount end]] } } } # update variable if some element need to be removed if {[llength $del_idx_list] > 0} { set del_idx_list [lsort -integer -unique $del_idx_list] set newpath [list] set nbelem [llength $dir_list] # rebuild list of element without indexes set for deletion for {set i 0} {$i < $nbelem} {incr i} { if {[notInList $del_idx_list $i]} { lappend newpath [lindex $dir_list $i] } } } else { set newpath $dir_list } # set env variable and corresponding reference counter in any case if {[llength $newpath] == 0} { unset-env $var } else { set-env $var [join $newpath $separator] } set sharevar [getModshareVarName $var] if {[array size countarr] > 0} { set-env $sharevar [pjoin [array get countarr] [getPathSeparator]] } else { unset-env $sharevar 1 } return {} } proc add-path {pos args} { reportDebug "($args) pos=$pos" lassign [eval parsePathCommandArgs add-path $args] separator allow_dup\ idx_val var path_list set sharevar [getModshareVarName $var] array set countarr [getReferenceCountArray $var $separator] if {$pos eq {prepend}} { set path_list [lreverse $path_list] } set val [get-env $var] foreach dir $path_list { if {![info exists countarr($dir)] || $allow_dup} { # ignore env var set empty if no empty entry found in reference # counter array (sometimes var is cleared by setting it empty not # unsetting it) if {$val ne {} || [info exists countarr()]} { set val [expr {$pos eq {prepend} ? "$dir$separator$val" :\ "$val$separator$dir"}] } else { set val $dir } } if {[info exists countarr($dir)]} { incr countarr($dir) } else { set countarr($dir) 1 } } set-env $var $val set-env $sharevar [pjoin [array get countarr] [getPathSeparator]] return {} } # analyze argument list passed to a path command to set default value or raise # error in case some attributes are missing proc parsePathCommandArgs {cmd args} { # parse argument list set next_is_delim 0 set allow_dup 0 set idx_val 0 foreach arg $args { # everything passed after variable name is considered a value if {[info exists var]} { # set multiple passed values in a list lappend val_raw_list $arg } else { switch -glob -- $arg { --index { if {$cmd eq {add-path}} { reportWarning "--index option has no effect on $cmd" } else { set idx_val 1 } } --duplicates { if {$cmd eq {unload-path}} { reportWarning "--duplicates option has no effect on $cmd" } else { set allow_dup 1 } } -d - -delim - --delim { set next_is_delim 1 } --delim=* { set delim [string range $arg 8 end] } -* { knerror "invalid option '$arg' for $cmd" } default { if {$next_is_delim} { set delim $arg set next_is_delim 0 } else { set var $arg } } } } } # adapt with default value or raise error if some arguments are missing if {![info exists delim]} { set delim [getPathSeparator] } elseif {$delim eq {}} { knerror "$cmd should get a non-empty path delimiter" } if {![info exists var]} { knerror "$cmd should get an environment variable name" } elseif {$var eq {}} { knerror "$cmd should get a valid environment variable name" } if {![info exists val_raw_list]} { knerror "$cmd should get a value for environment variable $var" } # set list of value to add set val_list [list] foreach val $val_raw_list { # check passed indexes are numbers if {$idx_val && ![string is integer -strict $val]} { knerror "$cmd should get valid number as index value" } switch -- $val \ {} { # add empty entry in list lappend val_list {} } \ $delim { knerror "$cmd cannot handle path equals to separator string" } \ default { # split passed value with delimiter set val_list [concat $val_list [split $val $delim]] } } reportDebug "(delim=$delim, allow_dup=$allow_dup, idx_val=$idx_val,\ var=$var, val=$val_list, nbval=[llength $val_list])" return [list $delim $allow_dup $idx_val $var $val_list] } proc prepend-path {args} { reportDebug $args # Set the variable for later use during the modulefile evaluation eval add-path prepend $args return {} } proc append-path {args} { reportDebug $args # Set the variable for later use during the modulefile evaluation eval add-path append $args return {} } proc remove-path {args} { reportDebug $args # Set the variable for later use during the modulefile evaluation eval unload-path $args return {} } # undo remove-path in unload mode proc remove-path-un {args} { # clear variable if it does not exist on unload mode for later use # during the modulefile evaluation lassign [eval parsePathCommandArgs unload-path $args] separator\ allow_dup idx_val var path_list if {![info exists ::env($var)]} { reset-to-unset-env $var } } # optimized *-path for whatis mode: init env variable with an empty value if # undefined. do not care about value, just avoid variable to be undefined for # later use during the modulefile evaluation proc edit-path-wh {args} { reportDebug $args # get variable name lassign [eval parsePathCommandArgs edit-path-wh $args] separator\ allow_dup idx_val var path_list if {![info exists ::env($var)]} { set ::env($var) {} } return {} } proc set-alias {alias what} { reportDebug "alias='$alias', val='$what'" set ::g_Aliases($alias) $what set ::g_stateAliases($alias) new return {} } # undo set-alias in unload mode proc set-alias-un {alias what} { return [unset-alias $alias] } proc unset-alias {alias} { reportDebug alias='$alias' set ::g_Aliases($alias) {} set ::g_stateAliases($alias) del return {} } proc set-function {function what} { reportDebug "function='$function', val='$what'" set ::g_Functions($function) $what set ::g_stateFunctions($function) new return {} } # undo set-function in unload mode proc set-function-un {function what} { return [unset-function $function] } proc unset-function {function} { reportDebug function='$function' set ::g_Functions($function) {} set ::g_stateFunctions($function) del return {} } proc is-loaded {args} { reportDebug $args # parse module version specification set args [eval parseModuleVersionSpecifier 0 $args] foreach mod $args { if {[getLoadedMatchingName $mod returnfirst] ne {}} { return 1 } } # is something loaded whatever it is? return [expr {[llength $args] == 0 && [llength [getLoadedModuleList]] > 0}] } proc is-loading {args} { reportDebug $args foreach mod $args { if {[getLoadedMatchingName $mod returnfirst 1] ne {}} { return 1 } } # is something else loading whatever it is? return [expr {[llength $args] == 0 && [llength [getLoadingModuleList]] >1}] } proc conflict {args} { reportDebug $args set currentModule [currentModuleName] # get module short name if loaded by its full pathname if {[set isfullpath [isModuleFullPath $currentModule]]} { set currentSModule [findModuleNameFromModulefile $currentModule] } defineModEqProc [isIcase] [getConf extended_default] # parse module version specification set args [eval parseModuleVersionSpecifier 0 $args] # register conflict list eval setLoadedConflict "{$currentModule}" $args foreach mod $args { # if the conflict module is loading and it does not correspond to # currently evaluated module, we cannot proceed set isloading [expr {![doesModuleMatchesName $currentModule $mod] &&\ (!$isfullpath || ![doesModuleMatchesName $currentSModule $mod]) &&\ [is-loading $mod]}] # if the conflicting module is loaded, we cannot either if {[is-loaded $mod] || $isloading} { set retisconun [isModuleEvaluated conun $currentModule $mod] # report message on currently evaluated module message block if {![set retiseval [isModuleEvaluated any $currentModule $mod]] ||\ [currentMsgRecordId] ne [topMsgRecordId] || !$retisconun} { # more appropriate msg if an eval was attempted or is by-passed set msg [expr {$retiseval || [getForce] ? [getConIsLoadedMsg\ [list $mod] $isloading] : [getErrConflictMsg $currentModule\ $mod]}] # still proceed if force mode enabled if {[getForce]} { reportWarning $msg # indicate message has already been reported lappend ::report_conflict($currentModule) $mod } else { knerror $msg MODULES_ERR_GLOBAL } } } } return {} } proc prereq {args} { reportDebug $args set currentModule [currentModuleName] # parse module version specification set args [eval parseModuleVersionSpecifier 0 $args] # register prereq list (sets of optional prereq are registered as list) setLoadedPrereq $currentModule $args # if dependency resolving is enabled try to load prereq if {[getConf auto_handling] && ![eval is-loaded $args] && ![eval\ is-loading $args]} { set imax [llength $args] set prereqloaded 0 # if prereq list specified, try to load first then # try next if load of first module not successful for {set i 0} {$i<$imax && $prereqloaded==0} {incr i 1} { set arg [lindex $args $i] # hold output of each evaluation until they are all done to drop # those that failed if one succeed set curholdid load-$i-$arg pushReportHoldId $curholdid if {[catch {cmdModuleLoad reqlo 0 $arg} errorMsg]} { # if an error is raised, release output and rethrow the error # (could be raised if no modulepath defined for instance) popReportHoldId lappend holdidlist $curholdid report eval releaseHeldReport $holdidlist knerror $errorMsg } popReportHoldId if {[is-loaded $arg]} { set prereqloaded 1 # set previous reports to be dropped as this one succeed if {[info exists holdidlist]} { foreach {holdid action} $holdidlist { lappend newholdidlist $holdid drop } set holdidlist $newholdidlist } } lappend holdidlist $curholdid report } # output held messages eval releaseHeldReport $holdidlist } if {![eval is-loaded $args] && ![eval is-loading $args]} { set retisreqlo [eval isModuleEvaluated reqlo "{$currentModule}" $args] # report message on currently evaluated module message block if {![set retiseval [eval isModuleEvaluated any "{$currentModule}"\ $args]] || [currentMsgRecordId] ne [topMsgRecordId] ||\ !$retisreqlo} { # more appropriate msg if an evaluation was attempted or is by-passed set msg [expr {$retiseval || [getForce] ? [getReqNotLoadedMsg $args]\ : [getErrPrereqMsg $currentModule $args]}] # still proceed if force mode enabled if {[getForce]} { reportWarning $msg # no error raise if done later } elseif {$retisreqlo} { reportError $msg } else { knerror $msg MODULES_ERR_GLOBAL } } # raise reqlo-specific msg to top level if attempted if {$retisreqlo} { set msg [getErrReqLoMsg $args] if {[getForce]} { reportWarning $msg 1 } else { knerror $msg MODULES_ERR_GLOBALTOP } } } return {} } proc x-resource {resource {value {}}} { reportDebug "($resource, $value)" # sometimes x-resource value may be provided within resource name # as the "x-resource {Ileaf.popup.saveUnder: True}" example provided # in manpage. so here is an attempt to extract real resource name and # value from resource argument if {[string length $value] == 0 && ![file exists $resource]} { # look first for a space character as delimiter, then for a colon set sepapos [string first { } $resource] if { $sepapos == -1 } { set sepapos [string first : $resource] } if { $sepapos > -1 } { set value [string range $resource [expr {$sepapos + 1}] end] set resource [string range $resource 0 [expr {$sepapos - 1}]] reportDebug "corrected ($resource, $value)" } else { # if not a file and no value provided x-resource cannot be # recorded as it will produce an error when passed to xrdb reportWarning "x-resource $resource is not a valid string or file" return {} } } # check current environment can handle X11 resource edition elsewhere exit if {[catch {runCommand xrdb -query} errMsg]} { knerror "X11 resources cannot be edited, issue spotted\n[sgr er\ ERROR]: $errMsg" MODULES_ERR_GLOBAL } # if a resource does hold an empty value in g_newXResources or # g_delXResources arrays, it means this is a resource file to parse if {[currentMode] eq {load}} { set ::g_newXResources($resource) $value } else { set ::g_delXResources($resource) $value } return {} } proc uname {what} { set result {} reportDebug $what if {! [info exists ::unameCache($what)]} { switch -- $what { sysname { set result $::tcl_platform(os) } machine { set result $::tcl_platform(machine) } nodename - node { set result [runCommand uname -n] } release { set result $::tcl_platform(osVersion) } domain { set result [runCommand domainname] } version { set result [runCommand uname -v] } default { knerror "uname $what not supported" } } set ::unameCache($what) $result } return $::unameCache($what) } # run shell command proc system {args} { reportDebug $args set mode [currentMode] set status {} switch -- $mode { load - unload { # run through the appropriate shell if {[isWin]} { set shell cmd.exe set shellarg /c } else { set shell /bin/sh set shellarg -c } if {[catch {exec >&@stderr $shell $shellarg [join $args]}]} { # non-zero exit status, get it: set status [lindex $::errorCode 2] } else { # exit status was 0 set status 0 } } } return $status } # test at least one of the collections passed as argument exists proc is-saved {args} { reportDebug $args foreach coll $args { lassign [getCollectionFilename $coll] collfile colldesc if {[file exists $collfile]} { return 1 } } # is something saved whatever it is? return [expr {[llength $args] == 0 && [llength [findCollections]] > 0}] } # test at least one of the directories passed as argument is set in MODULEPATH proc is-used {args} { reportDebug $args set modpathlist [getModulePathList] foreach path $args { # transform given path in an absolute path to compare with dirs # registered in the MODULEPATH env var which are returned absolute. set abspath [getAbsolutePath $path] if {[isInList $modpathlist $abspath]} { return 1 } } # is something used whatever it is? return [expr {[llength $args] == 0 && [llength $modpathlist] > 0}] } # test at least one of the modulefiles passed as argument exists proc is-avail {args} { reportDebug $args set ret 0 # disable error reporting to avoid modulefile errors # to pollute result. Only if not already inhibited set alreadyinhibit [isErrorReportInhibited] if {!$alreadyinhibit} { inhibitErrorReport } foreach mod $args { lassign [getPathToModule $mod] modfile modname if {$modfile ne {}} { set ret 1 break } } # re-enable only is it was disabled from this procedure if {!$alreadyinhibit} { reenableErrorReport } return $ret } ######################################################################## # internal module procedures # set g_modeStack {} proc currentMode {} { return [lindex $::g_modeStack end] } proc pushMode {mode} { lappend ::g_modeStack $mode } proc popMode {} { set ::g_modeStack [lrange $::g_modeStack 0 end-1] } set g_moduleNameStack {} proc currentModuleName {} { return [lindex $::g_moduleNameStack end] } proc pushModuleName {moduleName} { lappend ::g_moduleNameStack $moduleName } proc popModuleName {} { set ::g_moduleNameStack [lrange $::g_moduleNameStack 0 end-1] } # get number of either modulefile/modulerc currently being evaluated proc getEvalModuleStackDepth {} { return [llength $::g_moduleNameStack] } set g_moduleFileStack {} proc pushModuleFile {modfile} { lappend ::g_moduleFileStack $modfile set ::ModulesCurrentModulefile $modfile } proc popModuleFile {} { set ::g_moduleFileStack [lrange $::g_moduleFileStack 0 end-1] set ::ModulesCurrentModulefile [lindex $::g_moduleFileStack end] } set g_specifiedNameStack {} proc currentSpecifiedName {} { return [lindex $::g_specifiedNameStack end] } proc pushSpecifiedName {specifiedName} { lappend ::g_specifiedNameStack $specifiedName } proc popSpecifiedName {} { set ::g_specifiedNameStack [lrange $::g_specifiedNameStack 0 end-1] } set g_commandNameStack {} proc currentCommandName {} { return [lindex $::g_commandNameStack end] } proc aboveCommandName {} { return [lindex $::g_commandNameStack end-1] } proc pushCommandName {commandName} { lappend ::g_commandNameStack $commandName } proc popCommandName {} { set ::g_commandNameStack [lrange $::g_commandNameStack 0 end-1] } proc ongoingCommandName {commandName} { return [expr {[lsearch -exact $::g_commandNameStack $commandName] != -1}] } # stack of report holder unique identifiers set g_reportHoldIdStack {} proc isReportHeld {} { return [expr {[llength $::g_reportHoldIdStack] > 0}] } proc currentReportHoldId {} { return [lindex $::g_reportHoldIdStack end] } proc pushReportHoldId {holdid} { lappend ::g_reportHoldIdStack $holdid } proc popReportHoldId {} { set ::g_reportHoldIdStack [lrange $::g_reportHoldIdStack 0 end-1] } # stack of message recording/eval unique identifiers set g_evalIdStack {} set g_msgRecordIdStack {} proc currentMsgRecordId {} { return [lindex $::g_msgRecordIdStack end] } proc currentEvalId {} { return [lindex $::g_evalIdStack end] } proc topMsgRecordId {} { return [lindex $::g_msgRecordIdStack 0] } proc topEvalId {} { return [lindex $::g_evalIdStack 0] } proc pushMsgRecordId {recid {setmsgid 1}} { lappend ::g_evalIdStack $recid if {$setmsgid} { lappend ::g_msgRecordIdStack $recid } } proc popMsgRecordId {{setmsgid 1}} { set ::g_evalIdStack [lrange $::g_evalIdStack 0 end-1] if {$setmsgid} { set ::g_msgRecordIdStack [lrange $::g_msgRecordIdStack 0 end-1] } } proc clearAllMsgRecordId {} { set ::g_evalIdStack {} set ::g_msgRecordIdStack {} } # stack of prefixes clarifying debug message entries set g_debugMsgPrefixStack {} proc currentDebugMsgPrefix {} { return [lindex $::g_debugMsgPrefixStack end] } proc pushDebugMsgPrefix {args} { lappend ::g_debugMsgPrefixStack "\[#[join $args :]\] " } proc popDebugMsgPrefix {} { set ::g_debugMsgPrefixStack [lrange $::g_debugMsgPrefixStack 0 end-1] } # gather for the current top evaluation the information on all evaluations # happening under its umbrella proc registerModuleEval {context mod {unset 0} {failedcontext {}}} { set evalid [topEvalId] set contextset 0 # add mod to existing evaluation context list if {[info exists ::g_moduleEval($evalid)]} { for {set i 0} {$i < [llength $::g_moduleEval($evalid)]} {incr i 1} { set contextevallist [lindex $::g_moduleEval($evalid) $i] if {[lindex $contextevallist 0] eq $context} { if {$unset} { set contextevallist [replaceFromList $contextevallist $mod] } else { lappend contextevallist $mod } set ::g_moduleEval($evalid) [expr {[llength $contextevallist] > 1\ ? [lreplace $::g_moduleEval($evalid) $i $i $contextevallist]\ : [lreplace $::g_moduleEval($evalid) $i $i]}] set contextset 1 break } } } # add mod to new evaluation context list if {!$unset && !$contextset} { lappend ::g_moduleEval($evalid) [list $context $mod] } # add mod to failed evaluation list if {$unset} { lappend ::g_moduleFailedEval($evalid) $failedcontext $mod } } # get context of currently evaluated module proc currentModuleEvalContext {} { return [lindex $::g_moduleEvalAttempt([currentModuleName]) end] } # record module evaluation attempt and corresponding context proc registerModuleEvalAttempt {context mod} { appendNoDupToList ::g_moduleEvalAttempt($mod) $context } proc unregisterModuleEvalAttempt {context mod} { set ::g_moduleEvalAttempt($mod) [replaceFromList\ $::g_moduleEvalAttempt($mod) $context] } # is at least one module passed as argument evaluated in passed context proc isModuleEvaluated {context exclmod args} { set ret 0 set icase [isIcase] # look at all evaluated mod except excluded one (currently evaluated mod) foreach evalmod [lsearch -all -inline -not [array names\ ::g_moduleEvalAttempt] $exclmod] { set evalmatch 0 # test arguments against all names of evaluated module foreach mod [concat [list $evalmod] [getAllModuleResolvedName\ $evalmod]] { foreach name $args { if {[modEq $name $mod eqstart]} { set evalmatch 1 if {$context eq {any} || [isInList\ $::g_moduleEvalAttempt($evalmod) $context]} { set ret 1 } break } } if {$evalmatch} { break } } if {$ret} { break } } return $ret } # was passed mod already evaluated for context and failed proc isModuleEvalFailed {context mod} { set ret 0 set evalid [topEvalId] if {[info exists ::g_moduleFailedEval($evalid)]} { foreach {curcon curmod} $::g_moduleFailedEval($evalid) { if {$context eq $curcon && $mod eq $curmod} { set ret 1 break } } } return $ret } # stack of flag defining whether a modfile should be always fully read or not # even for validity check, which is useful in case a file need to be read # multiple times as a full read will make file content cached thus file will # be read only once set g_alwaysReadFullFileStack {} proc currentAlwaysReadFullFile {} { return [lindex $::g_alwaysReadFullFileStack end] } proc pushAlwaysReadFullFile {alwaysReadFullFile} { lappend ::g_alwaysReadFullFileStack $alwaysReadFullFile } proc popAlwaysReadFullFile {} { set ::g_alwaysReadFullFileStack [lrange $::g_alwaysReadFullFileStack 0\ end-1] } # return list of currently loading modules in stack proc getLoadingModuleList {} { set modlist [list] for {set i 0} {$i < [llength $::g_moduleNameStack]} {incr i 1} { if {[lindex $::g_modeStack $i] eq {load}} { lappend modlist [lindex $::g_moduleNameStack $i] } } return $modlist } # return list of currently loading modulefiles in stack proc getLoadingModuleFileList {} { set modlist [list] for {set i 0} {$i < [llength $::g_moduleFileStack]} {incr i 1} { if {[lindex $::g_modeStack $i] eq {load}} { lappend modlist [lindex $::g_moduleFileStack $i] } } return $modlist } # return list of currently unloading modules in stack proc getUnloadingModuleList {} { set modlist [list] for {set i 0} {$i < [llength $::g_moduleNameStack]} {incr i 1} { if {[lindex $::g_modeStack $i] eq {unload}} { lappend modlist [lindex $::g_moduleNameStack $i] } } return $modlist } # return list of loaded modules by parsing LOADEDMODULES env variable proc getLoadedModuleList {{filter_empty 1}} { set modlist [list] foreach mod [split [get-env LOADEDMODULES] [getPathSeparator]] { # ignore empty element if {$mod ne {} || !$filter_empty} { lappend modlist $mod } } return $modlist } # return list of loaded module files by parsing _LMFILES_ env variable proc getLoadedModuleFileList {} { set modfilelist [list] foreach modfile [split [get-env _LMFILES_] [getPathSeparator]] { # ignore empty element if {$modfile ne {}} { lappend modfilelist $modfile } } return $modfilelist } # return list of loaded module declared conflict by parsing MODULES_LMCONFLICT proc getLoadedModuleConflictList {} { set modconlist [list] foreach modconser [split [get-env MODULES_LMCONFLICT] [getPathSeparator]] { # recover range specifier ':' from its serialized form '<' set conlist [split [string map {< :} $modconser] $::g_sub1_separator] # ignore empty element (1 is meaningless as first elt is loaded mod) if {[llength $conlist] > 1} { lappend modconlist $conlist } } return $modconlist } # return list of loaded module declared prereq by parsing MODULES_LMPREREQ proc getLoadedModulePrereqList {} { set modprelist [list] foreach modpreser [split [get-env MODULES_LMPREREQ] [getPathSeparator]] { # recover range specifier ':' from its serialized form '<' set prelist [split [string map {< :} $modpreser] $::g_sub1_separator] # ignore empty element (1 is meaningless as first elt is loaded mod) if {[llength $prelist] > 1} { set modpre {} # keep first arg as string and other args as lists foreach pre $prelist { if {[llength $modpre] == 0} { lappend modpre $pre } else { lappend modpre [split $pre $::g_sub2_separator] } } lappend modprelist $modpre } } return $modprelist } # return list of loaded module asked by user by parsing MODULES_LMNOTUASKED proc getLoadedModuleNotUserAskedList {} { set nuaskedlist [list] foreach mod [split [get-env MODULES_LMNOTUASKED] [getPathSeparator]] { # ignore empty element if {$mod ne {}} { lappend nuaskedlist $mod } } return $nuaskedlist } # return list of loaded module declared altnames by parsing MODULES_LMALTNAME proc getLoadedModuleAltnameList {} { set modaltlist [list] foreach modaltser [split [get-env MODULES_LMALTNAME] [getPathSeparator]] { set altlist [split $modaltser $::g_sub1_separator] # ignore empty element (1 is meaningless as first elt is loaded mod) if {[llength $altlist] > 1} { lappend modaltlist $altlist } } return $modaltlist } # sort passed module list following both loaded and dependency orders proc sortModulePerLoadedAndDepOrder {modlist {nporeq 0} {loading 0}} { # sort per loaded order set sortlist {} if {[llength $modlist] > 0} { foreach lmmod [getLoadedModuleList] { if {[isInList $modlist $lmmod]} { lappend sortlist $lmmod } } # also sort eventual loading modules if asked if {$loading} { foreach loadingmod [lreverse [getLoadingModuleList]] { if {[isInList $modlist $loadingmod]} { lappend sortlist $loadingmod } } } } # then refine sort with dependencies between loaded modules: a dependent # module should be placed prior the loaded module requiring it set reqListVar [expr {$nporeq ? {::g_moduleNPODepend} :\ {::g_moduleDepend}}] set i 0 set imax [llength $sortlist] while {$i < $imax} { set mod [lindex $sortlist $i] set jmin $imax if {[info exists ${reqListVar}($mod)]} { # goes over all dependend modules to find the first one in the loaded # order list located after requiring mod foreach lmmodlist [set ${reqListVar}($mod)] { foreach lmmod $lmmodlist { set j [lsearch -exact $sortlist $lmmod] if {$j > $i && $j < $jmin} { set jmin $j set jminmod $lmmod } } } } # move first dependent module found after currently inspected mod right # before it if {$jmin != $imax} { set sortlist [linsert [lreplace $sortlist $jmin $jmin] $i $jminmod] # or go to next element in list if current element has not been changed } else { incr i } } return $sortlist } # return list of module paths by parsing MODULEPATH env variable # behavior param enables to exit in error when no MODULEPATH env variable # is set. by default an empty list is returned if no MODULEPATH set # resolv_var param tells if environement variable references in path elements # should be resolved or passed as-is in result list # set_abs param applies an absolute path name convertion to path elements # if enabled proc getModulePathList {{behavior returnempty} {resolv_var 1} {set_abs 1}} { if {[info exists ::env(MODULEPATH)]} { set modpathlist [list] foreach modpath [split $::env(MODULEPATH) [getPathSeparator]] { # ignore empty element if {$modpath ne {}} { if {$resolv_var} { set modpath [resolvStringWithEnv $modpath] } if {$set_abs} { set modpath [getAbsolutePath $modpath] } appendNoDupToList modpathlist $modpath } } return $modpathlist } elseif {$behavior eq {exiterronundef}} { reportErrorAndExit {No module path defined} } else { return {} } } # test if two modules share the same root name proc isSameModuleRoot {mod1 mod2} { set mod1split [split $mod1 /] set mod2split [split $mod2 /] return [expr {[lindex $mod1split 0] eq [lindex $mod2split 0]}] } # test if one module name from module specification is hidden proc isModuleSpecHidden {modspec} { set ret 0 foreach mod [getAllModulesFromVersSpec $modspec] { if {[isModuleHidden $mod]} { set ret 1 break } } return $ret } # test if one element in module name has a leading "dot" making this module # a hidden module proc isModuleHidden {mod} { foreach elt [split $mod /] { if {[string index $elt 0] eq {.}} { return 1 } } return 0 } # check if module name is specified as a full pathname (not a name relative # to a modulepath) proc isModuleFullPath {mod} { return [regexp {^(|\.|\.\.)/} $mod] } # check if a module corresponds to a virtual module (module name # does not corresponds to end of the modulefile name) proc isModuleVirtual {mod modfile} { return [expr {[string first $mod $modfile end-[string length $mod]] == -1}] } # Return the full pathname and modulename to the module. # Resolve aliases and default versions if the module name is something like # "name/version" or just "name" (find default version). proc getPathToModule {mod {indir {}} {report_issue 1} {look_loaded no}\ {excdir {}}} { reportDebug "finding '$mod' in '$indir' (report_issue=$report_issue,\ look_loaded=$look_loaded, excdir='$excdir')" if {$mod eq {}} { set retlist [list {} 0 none {Invalid empty module name}] # try first to look at loaded modules if enabled to find maching module # or to find a closest match (used when switching with single name arg) } elseif {$look_loaded ne {no}} { switch -- $look_loaded { match {set getLoadedNameProc getLoadedMatchingName} close {set getLoadedNameProc getLoadedWithClosestName} } set retlist [if {[set lm [$getLoadedNameProc $mod]] ne {}} {list\ [getModulefileFromLoadedModule $lm] $lm} {list {} $mod notloaded}] # Check for $mod specified as a full pathname } elseif {[isModuleFullPath $mod]} { set mod [getAbsolutePath $mod] # note that a raw filename as an argument returns the full # path as the module name lassign [checkValidModule $mod] check_valid check_msg switch -- $check_valid { true { set retlist [list $mod $mod] } invalid - accesserr { set retlist [list {} $mod $check_valid $check_msg $mod] } } } else { set dir_list [expr {$indir ne {} ? $indir : [getModulePathList\ exiterronundef]}] # remove excluded directories (already searched) foreach dir $excdir { set dir_list [replaceFromList $dir_list $dir] } # extract one module name from query set modqe [getOneModuleFromVersSpec $mod] set icase [isIcase] defineGetEqArrayKeyProc $icase [getConf extended_default] [getConf\ implicit_default] set modroot [lindex [split $modqe /] 0] # determine if we need to get hidden modules set fetch_hidden [isModuleSpecHidden $mod] # Now search for $mod in module paths foreach dir $dir_list { # get list of modules related to the root of searched module to get # in one call a complete list of any module kind (file, alias, etc) # related to search to be able to then determine in this proc the # correct module to return without restarting new searches array unset mod_list array set mod_list [getModules $dir $modroot 0 rc_defs_included\ $fetch_hidden] set prevmod {} set mod_res {} # loop to resolve correct modulefile in case specified mod is a # directory that should be analyzed to get default mod in it while {$prevmod ne $mod} { set mod [getEqArrayKey mod_list $mod] set prevmod $mod if {[info exists mod_list($mod)]} { switch -- [lindex $mod_list($mod) 0] { alias - version { set newmod [resolveModuleVersionOrAlias $mod $icase] # continue search on newmod if module from same root and # not hidden (if hidden search disabled) as mod_list # already contains everything related to this root module if {[isSameModuleRoot $mod $newmod] && ($fetch_hidden ||\ ![isModuleHidden $newmod])} { set mod $newmod # indicate an alias or a symbol was solved set mod_res $newmod # elsewhere restart search on new modulename, constrained # to specified dir if set } else { return [getPathToModule $newmod $indir $report_issue] } } directory { # is implicit default disabled and none explicitly set? if {[lindex $mod_list($mod) 1] eq {}} { set retlist [list {} $mod none "No default version\ defined for '$mod'"] } else { # Move to default element in directory set mod $mod/[lindex $mod_list($mod) 1] # restart search if default element is hidden and # hidden elements were not searched if {!$fetch_hidden && [isModuleHidden $mod]} { return [getPathToModule $mod $indir $report_issue] } } } modulefile { # If mod was a file in this path, return that file set retlist [list $dir/$mod $mod] } virtual { # return virtual name with file it targets set retlist [list [lindex $mod_list($mod) 2] $mod] } invalid - accesserr { # may found mod but issue, so end search with error set retlist [concat [list {} $mod] $mod_list($mod)] } } } } # break loop if found something (valid or invalid module) # elsewhere go to next path if {[info exists retlist]} { break # found nothing after solving a matching alias or symbol } elseif {$mod_res eq $mod} { lappend excdir $dir # look for this name in the other module paths, so restart # directory search from first dir in list to ensure precedence return [getPathToModule $mod $indir $report_issue no $excdir] } } } # set result if nothing found if {![info exists retlist]} { set retlist [list {} $mod none "Unable to locate a modulefile for\ '$mod'"] } if {[lindex $retlist 0] ne {}} { reportDebug "found '[lindex $retlist 0]' as '[lindex $retlist 1]'" # no error if we look at loaded modules and passed mod not found loaded } elseif {[lindex $retlist 2] ne {notloaded} && $report_issue} { eval reportIssue [lrange $retlist 2 4] } return $retlist } proc isModuleLoaded {mod} { cacheCurrentModules return [info exists ::g_loadedModules($mod)] } proc getModulefileFromLoadedModule {mod} { if {[isModuleLoaded $mod]} { return $::g_loadedModules($mod) } else { return {} } } proc isModulefileLoaded {modfile} { cacheCurrentModules return [info exists ::g_loadedModuleFiles($modfile)] } proc getModuleFromLoadedModulefile {modfile {idx all}} { if {[isModulefileLoaded $modfile]} { if {$idx eq {all}} { return $::g_loadedModuleFiles($modfile) } else { return [lindex $::g_loadedModuleFiles($modfile) $idx] } } else { return {} } } proc isModuleLoading {mod} { return [isInList [getLoadingModuleList] $mod] } proc isModulefileLoading {modfile} { return [isInList [getLoadingModuleFileList] $modfile] } proc getModuleFromLoadingModulefile {modfile {idx all}} { if {[isModulefileLoading $modfile]} { set loadingmodlist [getLoadingModuleList] foreach i [lsearch -all -exact [getLoadingModuleFileList] $modfile] { lappend modlist [lindex $loadingmodlist $i] } if {$idx eq {all}} { return $modlist } else { return [lindex $modlist $idx] } } else { return {} } } proc setLoadedModule {mod modfile uasked} { set ::g_loadedModules($mod) $modfile # a loaded modfile may correspond to multiple loaded virtual modules lappend ::g_loadedModuleFiles($modfile) $mod # record if mod has been asked by user if {$uasked} { set ::g_loadedModuleUasked($mod) 1 } # build dependency chain setModuleDependency $mod } proc unsetLoadedModule {mod modfile} { unset ::g_loadedModules($mod) # a loaded modfile may correspond to multiple loaded virtual modules if {[llength $::g_loadedModuleFiles($modfile)] == 1} { unset ::g_loadedModuleFiles($modfile) } else { set ::g_loadedModuleFiles($modfile) [replaceFromList\ $::g_loadedModuleFiles($modfile) $mod] } if {[info exists ::g_loadedModuleUasked($mod)]} { unset ::g_loadedModuleUasked($mod) } # update dependencies unsetModuleDependency $mod } # Define procedure to get how many parts between passed name and mod are equal # Adapt procedure code whether icase is enabled or disabled proc defineModStartNbProc {icase} { set procname modStartNbProc if {$icase} { append procname Icase } # define proc if not done yet or if it was defined for another context if {[info procs modStartNb] eq {} || $::g_modStartNb_proc ne $procname} { if {[info exists ::g_modStartNb_proc]} { rename ::modStartNb ::$::g_modStartNb_proc } rename ::$procname ::modStartNb set ::g_modStartNb_proc $procname } } # alternative definitions of modStartNb proc proc modStartNbProc {mod name} { # first compare against name's parent chunk by chunk set modname [getModuleNameFromVersSpec $name] if {$modname eq {.}} { set i -1 set imax -1 } else { set namesplit [split $modname /] set modsplit [split $mod /] # min expr function is not supported in Tcl8.4 and earlier set imax [if {[llength $namesplit] < [llength $modsplit]} {llength\ $namesplit} {llength $modsplit}] for {set i 0} {$i < $imax} {incr i} { if {![string equal [lindex $modsplit $i] [lindex $namesplit $i]]} { incr i -1 break } } } # if name's parent matches check if full name also matches if {$i == $imax && [modEq $name $mod eqstart]} { incr i } return $i } proc modStartNbProcIcase {mod name} { set modname [getModuleNameFromVersSpec $name] if {$modname eq {.}} { set i -1 set imax -1 } else { set namesplit [split $modname /] set modsplit [split $mod /] set imax [if {[llength $namesplit] < [llength $modsplit]} {llength\ $namesplit} {llength $modsplit}] for {set i 0} {$i < $imax} {incr i} { if {![string equal -nocase [lindex $modsplit $i] [lindex $namesplit\ $i]]} { incr i -1 break } } } if {$i == $imax && [modEq $name $mod eqstart]} { incr i } return $i } # check if name matches passed mod name or one of its alternative name proc doesModuleMatchesName {mod name} { cacheCurrentModules set ret 0 # check if main or alternative names of loaded mod matches passed name foreach matchmod [concat [list $mod] [getLoadedAltname $mod]] { if {[modEq $name $matchmod eqstart]} { set ret 1 break } } return $ret } # check if name matches one name of passed loading mod (main or alternative) proc doesLoadingModuleMatchesName {mod name} { set ret 0 # check if main or alternative names of loading mod matches passed name # directly look at all resolved names structure as alternative names for # loading modules are not yet registered elsewhere foreach matchmod [concat [list $mod] [getAllModuleResolvedName $mod]] { if {[modEq $name $matchmod eqstart]} { set ret 1 break } } return $ret } # return the currently loaded module whose name is the closest to the # name passed as argument. if no loaded module match at least one part # of the passed name, an empty string is returned. proc getLoadedWithClosestName {name} { set ret {} set retmax 0 if {[isModuleFullPath $name]} { set fullname [getAbsolutePath $name] # if module is passed as full modulefile path name, get corresponding # short name from used modulepaths if {[set shortname [findModuleNameFromModulefile $fullname]] ne {}} { set nametosplit $shortname # or look at lmfile names to return the eventual exact match } else { # module may be loaded with its full path name if {[isModuleLoaded $fullname]} { set ret $fullname # or name corresponds to the _lmfiles_ entry of a virtual modules in # which case lastly loaded virtual module is returned } elseif {[isModulefileLoaded $fullname]} { set ret [getModuleFromLoadedModulefile $fullname end] } } } else { set nametosplit $name } if {[info exists nametosplit]} { cacheCurrentModules set icase [isIcase] defineModStartNbProc $icase defineModEqProc $icase [getConf extended_default] # compare name to each currently loaded module name foreach mod [getLoadedModuleList] { # if module loaded as fullpath but test name not, try to get loaded # mod short name (with currently used modulepaths) to compare it if {[isModuleFullPath $mod] && [set modname\ [findModuleNameFromModulefile $mod]] ne {}} { # no alt name to retrieve if module has been loaded full path set matchmodlist [list $modname] } else { # add alternative names of mod to the matching list set matchmodlist [concat [list $mod] [getLoadedAltname $mod]] } # compare each element of the name to find closest answer. in case of # equality, last loaded module will be returned as it overwrites # previously found value foreach matchmod $matchmodlist { if {[set i [modStartNb $matchmod $nametosplit]] >= $retmax} { set retmax $i set ret $mod break } } } } reportDebug "'$ret' closest to '$name'" return $ret } # return the currently loaded module whose name is equal or include the name # passed as argument. if no loaded module match, an empty string is returned. # loading: look at currently loading modules instead of loaded if loading == 1 # lmlist: only take into account passed loaded module list not all loaded mods proc getLoadedMatchingName {name {behavior {}} {loading 0} {lmlist {}}} { set ret {} set retmax 0 # get default behavior from unload_match_order config if {$behavior eq {}} { set behavior [getConf unload_match_order] } # use loading-specific procedures instead of loaded-specific ones if {$loading} { set isModulefileLoaded isModulefileLoading set getModuleFromLoadedModulefile getModuleFromLoadingModulefile set getLoadedModuleList getLoadingModuleList set doesModuleMatchesName doesLoadingModuleMatchesName } else { set isModulefileLoaded isModulefileLoaded set getModuleFromLoadedModulefile getModuleFromLoadedModulefile set getLoadedModuleList getLoadedModuleList set doesModuleMatchesName doesModuleMatchesName } # fetch currently loaded/loading module name is no list provided if {[llength $lmlist] == 0} { set lmlist [$getLoadedModuleList] } # if module is passed as full modulefile path name, look at lmfile names # to return the eventual exact match if {[isModuleFullPath $name]} { set mod [getAbsolutePath $name] # if module is loaded with its full path name loadedmodules entry is # equivalent to _lmfiles_ corresponding entry so only check _lmfiles_ if {[$isModulefileLoaded $mod]} { # a loaded modfile may correspond to multiple loaded virtual modules switch -- $behavior { returnlast { # the last loaded/loading module will be returned set ret [$getModuleFromLoadedModulefile $mod end] } returnfirst { # the first loaded/loading module will be returned set ret [$getModuleFromLoadedModulefile $mod 0] } returnall { # all loaded/loading modules will be returned set ret [$getModuleFromLoadedModulefile $mod] } } } } elseif {$name ne {}} { defineModEqProc [isIcase] [getConf extended_default] # compare name to each currently loaded/loading module name, if multiple # mod match name: foreach mod $lmlist { # if module loaded as fullpath but test name not, try to get loaded # mod short name (with currently used modulepaths) to compare it if {[isModuleFullPath $mod] && [set modname\ [findModuleNameFromModulefile $mod]] ne {}} { set matchmod $modname } else { set matchmod $mod } if {[$doesModuleMatchesName $matchmod $name]} { switch -- $behavior { returnlast { # the last loaded module will be returned set ret $mod } returnfirst { # the first loaded module will be returned set ret $mod break } returnall { # all loaded modules will be returned lappend ret $mod } } } } } reportDebug "'$ret' matches '$name'" return $ret } proc setLoadedConflict {mod args} { eval appendNoDupToList "{::g_loadedModuleConflict($mod)}" $args } proc unsetLoadedConflict {mod} { if {[info exists ::g_loadedModuleConflict($mod)]} { unset ::g_loadedModuleConflict($mod) } } proc getLoadedConflict {mod {serialized 0}} { set ret {} if {[info exists ::g_loadedModuleConflict($mod)]} { if {$serialized} { # get conflict info as a string that can be registered in an env var # translate range specifier ':' into '<' to distinguish from path sep set ret [string map {: <} [join [concat [list $mod]\ $::g_loadedModuleConflict($mod)] $::g_sub1_separator]] } else { set ret $::g_loadedModuleConflict($mod) } } return $ret } proc doesModuleConflict {mod} { set does 0 set modconlist {} set moddecconlist {} defineModEqProc [isIcase] [getConf extended_default] # get module short name if loaded by its full pathname if {[set isfullpath [isModuleFullPath $mod]]} { set smod [findModuleNameFromModulefile $mod] } # check if any loaded module has declared a conflict foreach modcon [array names ::g_loadedModuleConflict] { # look if some loaded or loading modules correspond to conflict defined # by mod if {$modcon eq $mod || ($isfullpath && $modcon eq $smod)} { foreach withmod $::g_loadedModuleConflict($modcon) { # skip own reflexive conflict (look at mod main and alternative # names) and those already known if {![doesModuleMatchesName $mod $withmod] && (!$isfullpath ||\ ![doesModuleMatchesName $smod $withmod]) && ([set lmmodlist\ [getLoadedMatchingName $withmod returnall]] ne {} || [set\ lmmodlist [getLoadedMatchingName $withmod returnall 1]] ne {})} { # multiple loaded module may match conflict declared name foreach lmmod $lmmodlist { appendNoDupToList modconlist $lmmod } appendNoDupToList moddecconlist $withmod set does 1 } } # other loaded module declared conflicts (skipping those already known) } elseif {[notInList $modconlist $modcon]} { foreach withmod $::g_loadedModuleConflict($modcon) { # check if mod or one of its alt name match conflict if {[doesModuleMatchesName $mod $withmod] || ($isfullpath &&\ [doesModuleMatchesName $smod $withmod])} { lappend modconlist $modcon lappend moddecconlist $modcon set does 1 break } } } } reportDebug "'$mod' conflicts with '$modconlist' (declared as '$moddecconlist')" return [list $does $modconlist $moddecconlist] } proc setLoadedPrereq {mod args} { eval appendNoDupToList "{::g_loadedModulePrereq($mod)}" $args } proc unsetLoadedPrereq {mod} { if {[info exists ::g_loadedModulePrereq($mod)]} { unset ::g_loadedModulePrereq($mod) } } proc getLoadedPrereq {mod {serialized 0}} { set ret {} if {[info exists ::g_loadedModulePrereq($mod)]} { if {$serialized} { # get prereq info as a string that can be registered in an env var foreach pre $::g_loadedModulePrereq($mod) { lappend modpre [join $pre $::g_sub2_separator] } # translate range specifier ':' into '<' to distinguish from path sep set ret [string map {: <} [join [concat [list $mod] $modpre]\ $::g_sub1_separator]] } else { set ret $::g_loadedModulePrereq($mod) } } return $ret } proc setLoadedAltname {mod args} { foreach arg $args { if {[string range $arg 0 2] eq {as|}} { appendNoDupToList ::g_loadedModuleAutoAltname($mod) [string range\ $arg 3 end] } else { appendNoDupToList ::g_loadedModuleAltname($mod) $arg } } } proc unsetLoadedAltname {mod} { if {[info exists ::g_loadedModuleAltname($mod)]} { unset ::g_loadedModuleAltname($mod) } if {[info exists ::g_loadedModuleAutoAltname($mod)]} { unset ::g_loadedModuleAutoAltname($mod) } } proc getLoadedAltname {mod {serialized 0}} { set ret {} if {[info exists ::g_loadedModuleAltname($mod)]} { set ret $::g_loadedModuleAltname($mod) } if {[info exists ::g_loadedModuleAutoAltname($mod)]} { if {$serialized} { # add a 'as|' prefix to each auto sym to distinguish them when # serialized foreach altname $::g_loadedModuleAutoAltname($mod) { lappend ret as|$altname } } else { set ret [concat $ret $::g_loadedModuleAutoAltname($mod)] } } if {$ret ne {} && $serialized} { # get altname info as a string that can be registered in an env var set ret [join [concat [list $mod] $ret] $::g_sub1_separator] } return $ret } proc isModuleUserAsked {mod} { cacheCurrentModules return [info exists ::g_loadedModuleUasked($mod)] } # register conflict violation state between loaded modules proc setModuleConflictViolation {mod modconlist} { reportDebug "set conflict violation state for '$mod'" set ::g_conflictViolation($mod) $modconlist # also update violation state for loaded mod conflicting with mod foreach lmmod $modconlist { if {[appendNoDupToList ::g_conflictViolation($lmmod) $mod]} { reportDebug "set/update conflict violation state for '$lmmod'" } } } # unregister conflict violation state between modules proc unsetModuleConflictViolation {mod} { if {[info exists ::g_conflictViolation($mod)]} { # also update violation state for loaded mod conflicting with mod foreach lmmod $::g_conflictViolation($mod) { set convio [replaceFromList\ $::g_conflictViolation($lmmod) $mod] reportDebug "unset/update conflict violation state for '$lmmod'" if {[llength $convio] == 0} { unset ::g_conflictViolation($lmmod) } else { set ::g_conflictViolation($lmmod) $convio } } reportDebug "unset conflict violation state for '$mod'" unset ::g_conflictViolation($mod) } } # build dependency chain between loaded modules based on registered prereqs proc setModuleDependency {mod} { set modlist [getLoadedModuleList] defineModEqProc [isIcase] [getConf extended_default] # only look at modules loaded prior current one to find requirements, # modules loaded afterward are unmet dependencies as dependents have # not been reloaded after them set modidx [lsearch -exact $modlist $mod] set modnpolist [lrange $modlist [expr {$modidx + 1}] end] set modlist [lrange $modlist 0 $modidx] # reverse list to get closest match if returning lastly loaded module if {[getConf unload_match_order] eq {returnlast}} { set modlist [lreverse $modlist] } set deplist {} set depnpolist {} foreach prereq [getLoadedPrereq $mod] { # get corresponding loaded module for each element of the prereq order set lmprelist {} set lmnpolist {} foreach modpre $prereq { set lmfound {} foreach lmmod $modlist { if {[doesModuleMatchesName $lmmod $modpre]} { set lmfound $lmmod break } } # register an unmet dependency/requirement if no loaded mod matches if {$lmfound eq {}} { reportDebug "set an unmet requirement on '$modpre' for '$mod'" lappend ::g_moduleUnmetDep($mod) $modpre lappend ::g_unmetDepHash($modpre) $mod # add matching mod elsewhere } else { appendNoDupToList lmprelist $lmfound appendNoDupToList lmnpolist $lmfound } # look if requirement can be found in the No Particular Order list foreach lmmod $modnpolist { if {[doesModuleMatchesName $lmmod $modpre]} { appendNoDupToList lmnpolist $lmmod break } } } switch -- [llength $lmprelist] { 0 { # prereq not satisfied reportDebug "set prereq violation state for '$mod'" lappend ::g_prereqViolation($mod) $prereq } 1 { set lmmod [lindex $lmprelist 0] lappend deplist [list $lmmod] # set 'is depended by' relations lappend ::g_dependHash($lmmod) [list $mod] } default { lappend deplist $lmprelist # many modules in prereq list, means they all set an optional dep foreach lmmod $lmprelist { lappend ::g_dependHash($lmmod) [list $mod 1] } } } # build 'is depended by' relations not taking loading order into account switch -- [llength $lmnpolist] { 0 { # even on No Particular Order mode, prereq is not satisfied reportDebug "set NPO prereq violation state for '$mod'" lappend ::g_prereqNPOViolation($mod) $prereq } 1 { set lmmod [lindex $lmnpolist 0] lappend depnpolist [list $lmmod] # set 'is depended by' relations lappend ::g_dependNPOHash($lmmod) [list $mod] } default { lappend depnpolist $lmnpolist # many modules in prereq list, means they all set an optional dep foreach lmmod $lmnpolist { lappend ::g_dependNPOHash($lmmod) [list $mod 1] } } } } # conflict not satisfied lassign [doesModuleConflict $mod] doescon modconlist if {$doescon} { setModuleConflictViolation $mod $modconlist } # update eventual registered unmet dependencies foreach modpre [array names ::g_unmetDepHash] { if {[doesModuleMatchesName $mod $modpre]} { reportDebug "refresh requirements targetting '$modpre'" foreach lmmod $::g_unmetDepHash($modpre) { if {[isInList [getDependentLoadedModuleList [list $lmmod] 0 0]\ $mod]} { reportDebug "skip deps refresh for '$lmmod' as dep cycle\ detected with '$mod'" # remove dependency link in no particular order structs to # avoid cycle first in 'is depended by' struct if {[info exists ::g_dependNPOHash($mod)]} { set depmodlist $::g_dependNPOHash($mod) for {set i 0} {$i < [llength $depmodlist]} {incr i 1} { if {[lindex [lindex $depmodlist $i] 0] eq $lmmod} { set depmodlist [lreplace $depmodlist $i $i] break } } set ::g_dependNPOHash($mod) $depmodlist reportDebug "update NPO dependent of '$mod' to\ '$depmodlist'" } # then update 'depend on' struct set lmmoddepnpolist {} foreach depmodlist $::g_moduleNPODepend($lmmod) { if {[set depidx [lsearch -exact $depmodlist $mod]] != -1} { set depmodlist [lreplace $depmodlist $depidx $depidx] # implies to update consistenly alternate requirement or # violation state if no alternative loaded switch -- [llength $depmodlist] { 0 { # do not know exact prereq name, so use correspond. # loaded module matching it lappend ::g_prereqNPOViolation($lmmod) $mod reportDebug "set NPO prereq violation state for\ '$lmmod'" } 1 { # update alternate loaded mod which became a strong # requirement set altmod [lindex $depmodlist 0] set ::g_dependNPOHash($altmod) [replaceFromList\ $::g_dependNPOHash($altmod) [list $lmmod 1]\ $lmmod] reportDebug "update NPO dependent of '$altmod' to\ '$::g_dependNPOHash($altmod)'" } } } lappend lmmoddepnpolist $depmodlist } reportDebug "update NPO requirement of '$lmmod' to\ '$lmmoddepnpolist'" set ::g_moduleNPODepend($lmmod) $lmmoddepnpolist } else { # refresh actual dependencies of targetting mod unsetModuleDependency $lmmod setModuleDependency $lmmod } } } } # set 'depends on' relation reportDebug "set requirements of '$mod' to '$deplist'" set ::g_moduleDepend($mod) $deplist reportDebug "set NPO requirements of '$mod' to '$depnpolist'" set ::g_moduleNPODepend($mod) $depnpolist } # update dependency chain when unloading module proc unsetModuleDependency {mod} { foreach lmmodlist $::g_moduleDepend($mod) { set manymod [expr {[llength $lmmodlist] > 1 ? 1 : 0}] # unset 'is depended by' mod relations foreach lmmod $lmmodlist { if {[info exists ::g_dependHash($lmmod)]} { if {$manymod} { set hashdep [list $mod 1] } else { set hashdep [list $mod] } set ::g_dependHash($lmmod) [replaceFromList\ $::g_dependHash($lmmod) $hashdep] if {[llength $::g_dependHash($lmmod)] == 0} { unset ::g_dependHash($lmmod) } } } } # unset mod's 'depends on' relation reportDebug "unset requirements of '$mod'" unset ::g_moduleDepend($mod) foreach lmmodlist $::g_moduleNPODepend($mod) { set manymod [expr {[llength $lmmodlist] > 1 ? 1 : 0}] # unset 'is depended by' mod relations foreach lmmod $lmmodlist { if {[info exists ::g_dependNPOHash($lmmod)]} { if {$manymod} { set hashdep [list $mod 1] } else { set hashdep [list $mod] } set ::g_dependNPOHash($lmmod) [replaceFromList\ $::g_dependNPOHash($lmmod) $hashdep] if {[llength $::g_dependNPOHash($lmmod)] == 0} { unset ::g_dependNPOHash($lmmod) } } } } # unset mod's No Particular Order 'depends on' relation reportDebug "unset NPO requirements of '$mod'" unset ::g_moduleNPODepend($mod) # unset eventual violation states if {[info exists ::g_prereqViolation($mod)]} { reportDebug "unset prereq violation state for '$mod'" unset ::g_prereqViolation($mod) } if {[info exists ::g_prereqNPOViolation($mod)]} { reportDebug "unset NPO prereq violation state for '$mod'" unset ::g_prereqNPOViolation($mod) } unsetModuleConflictViolation $mod # unset eventual registered unmet dependencies if {[info exists ::g_moduleUnmetDep($mod)]} { foreach ummod $::g_moduleUnmetDep($mod) { if {[info exists ::g_unmetDepHash($ummod)]} { set ::g_unmetDepHash($ummod) [replaceFromList\ $::g_unmetDepHash($ummod) $mod] if {[llength $::g_unmetDepHash($ummod)] == 0} { unset ::g_unmetDepHash($ummod) } } } reportDebug "unset unmet requirements for '$mod'" unset ::g_moduleUnmetDep($mod) } # unset mod's 'is depended by' relations set hashdeplist [getDirectDependentList $mod] if {[llength $hashdeplist] > 0} { reportDebug "refresh dependent of '$mod'" foreach lmmod $hashdeplist { # refresh actual dependencies of targetting mod unsetModuleDependency $lmmod setModuleDependency $lmmod } } } # returns if any loaded module (if passed mod is empty) or passed mod and all # its requirement chain satisfy their loading constraints (prereq & conflict) proc areModuleConstraintsSatisfied {{mod {}} {nporeq 0}} { set ret 1 cacheCurrentModules # are requirements loaded after their dependent included or not if {$nporeq} { set reqVioVar ::g_prereqNPOViolation set reqListVar ::g_moduleNPODepend } else { set reqVioVar ::g_prereqViolation set reqListVar ::g_moduleDepend } # check if any loaded module violates its prereq or conflict constraints if {$mod eq {}} { if {[array size ::g_conflictViolation] > 0 || [array size\ $reqVioVar] > 0} { set ret 0 } } else { set fulllist [list $mod] for {set i 0} {$i < [llength $fulllist]} {incr i 1} { set depmod [lindex $fulllist $i] # check if depmod violates its prereq or conflict constraints if {[info exists ::g_conflictViolation($depmod)] || [info exists\ ${reqVioVar}($depmod)]} { # found violation among the requirement chain of mod so the # constraint of mod are not satisfied set ret 0 break } # add requirements of depmod to the module to check list foreach lmmodlist [set ${reqListVar}($depmod)] { eval appendNoDupToList fulllist $lmmodlist } } } return $ret } # return list of loaded modules having an unmet requirement on passed mod # and their recursive dependent proc getUnmetDependentLoadedModuleList {mod} { reportDebug "get dependent of upcoming loaded '$mod'" set unmetdeplist {} set depmodlist {} defineModEqProc [isIcase] [getConf extended_default] # skip dependent analysis if mod has a conflict with a loaded module lassign [doesModuleConflict $mod] doescon modconlist if {!$doescon} { foreach ummod [array names ::g_unmetDepHash] { if {[doesModuleMatchesName $mod $ummod]} { foreach depmod $::g_unmetDepHash($ummod) { lappend depmodlist $depmod # temporarily remove prereq violation of depmod if mod # load solves it (no other prereq is missing) if {[info exists ::g_prereqViolation($depmod)]} { foreach prereq $::g_prereqViolation($depmod) { foreach modpre $prereq { # also temporarily remove prereq violation for # requirements loaded after dependent module if {[doesModuleMatchesName $mod $modpre] ||\ [is-loaded $modpre]} { # backup original violation to restore it later if {![info exists preunvioarr($depmod)]} { set preunvioarr($depmod)\ $::g_prereqViolation($depmod) } # temporarily remove matching violation set ::g_prereqViolation($depmod) [replaceFromList\ $::g_prereqViolation($depmod) $prereq] if {[llength $::g_prereqViolation($depmod)] == 0} { unset ::g_prereqViolation($depmod) } break } } } } } } } } # select dependent if all its constraint are now satisfied (after removing # eventual prereq violation toward mod) foreach depmod $depmodlist { if {[areModuleConstraintsSatisfied $depmod]} { appendNoDupToList unmetdeplist $depmod } } # get dependent of dependent set deplist [getDependentLoadedModuleList $unmetdeplist 0 0 0 0 1] # restore temporarily lift prereq violation if {[array exists preunvioarr]} { foreach depmod [array names preunvioarr] { set ::g_prereqViolation($depmod) $preunvioarr($depmod) } } set sortlist [sortModulePerLoadedAndDepOrder [concat $unmetdeplist\ $deplist]] reportDebug "got '$sortlist'" return $sortlist } # return list of loaded modules declaring a prereq on passed mod with # distinction made with strong prereqs (no alternative loaded) or weak and # also with prereq loaded after their dependent module proc getDirectDependentList {mod {strong 0} {nporeq 0} {loading 0}\ {othmodlist {}}} { set deplist {} # include or not requirements loaded after their dependent if {$nporeq} { set depListVar ::g_dependNPOHash set reqListVar ::g_moduleNPODepend } else { set depListVar ::g_dependHash set reqListVar ::g_moduleDepend } if {[info exists ${depListVar}($mod)]} { foreach depmod [set ${depListVar}($mod)] { set add 1 # skip optional dependency if only looking for strong ones # look at an additionally processed mod list to determine if all # mods from a dependent list (composed of optional parts) are part # of the search, which means mod is not optional but strong dependent if {$strong && [llength $depmod] > 1} { foreach lmmodlist [set ${reqListVar}([lindex $depmod 0])] { if {[isInList $lmmodlist $mod]} { foreach lmmod $lmmodlist { # other mod part of the opt list is not there so mod # is considered optional if {[notInList $othmodlist $lmmod]} { set add 0 break } } break } } } if {$add} { lappend deplist [lindex $depmod 0] } } } # take currently loading modules into account if asked if {$loading} { set modlist [getLoadedModuleList] defineModEqProc [isIcase] [getConf extended_default] # reverse list to get closest match if returning lastly loaded module if {[getConf unload_match_order] eq {returnlast}} { set modlist [lreverse $modlist] } foreach loadingmod [getLoadingModuleList] { foreach prereq [getLoadedPrereq $loadingmod] { set lmprelist {} set moddep 0 foreach modpre $prereq { foreach lmmod $modlist { if {[doesModuleMatchesName $lmmod $modpre]} { lappend lmprelist $lmmod if {$lmmod eq $mod} { set moddep 1 } break } } } if {$moddep && (!$strong || [llength $lmprelist] == 1)} { lappend deplist $loadingmod break } } } } return $deplist } # gets the list of all loaded modules which are dependent of passed modlist # ordered by load position. strong argument controls whether only the active # dependent modules should be returned or also those that are optional. direct # argument controls if only dependent module directly requiring passed mods # should be returned or its full dependent tree. nporeq argument tells if # requirement loaded after their dependent should be returned. sat_constraint # argument controls whether only the loaded module satisfying their constraint # should be part or not of the resulting list. being_unload argument controls # whether loaded modules in conflict with one or multiple modules from modlist # should be added to the dependent list as these modules are currently being # unloaded and these conflicting loaded modules should be refreshed. proc getDependentLoadedModuleList {modlist {strong 1} {direct 1} {nporeq 0}\ {loading 1} {sat_constraint 0} {being_unload 0}} { reportDebug "get loaded mod dependent of '$modlist' (strong=$strong,\ direct=$direct, nporeq=$nporeq, loading=$loading,\ sat_constraint=$sat_constraint, being_unload=$being_unload)" set deplist {} set fulllist $modlist # look at consistent requirements for unloading modules set unlonporeq [expr {$being_unload ? 0 : $nporeq}] foreach mod $modlist { # no duplicates or modules from query list eval appendNoDupToList fulllist [getDirectDependentList $mod $strong\ $unlonporeq $loading $fulllist] } if {$being_unload} { # invite modules in violation with mods to be part of the dependent list # with their own dependent modules as mod is being unloaded. Achieve so # by faking that conflict violation is gone foreach mod $modlist { lassign [doesModuleConflict $mod] doescon modconlist if {$doescon} { unsetModuleConflictViolation $mod set conunvioarr($mod) $modconlist eval appendNoDupToList fulllist $modconlist } } } set unloadingmodlist [getUnloadingModuleList] for {set i [llength $modlist]} {$i < [llength $fulllist]} {incr i 1} { set depmod [lindex $fulllist $i] # skip already added mod or mod violating constraints if asked if {!$sat_constraint || [areModuleConstraintsSatisfied $depmod\ $nporeq]} { # get dependent mod of dep mod when looking at full dep tree if {!$direct} { eval appendNoDupToList fulllist [getDirectDependentList $depmod\ $strong $nporeq 0 $fulllist] } # avoid module currently unloading from result list if {[notInList $unloadingmodlist $depmod]} { lappend deplist $depmod } } } # restore conflict violation if any if {[array exists conunvioarr]} { foreach conunvio [array names conunvioarr] { setModuleConflictViolation $conunvio $conunvioarr($conunvio) } } # sort complete result list to match both loaded and dependency orders set sortlist [sortModulePerLoadedAndDepOrder $deplist $nporeq $loading] reportDebug "got '$sortlist'" return $sortlist } # test if passed 'mod' could be automatically unloaded or not, which means it # has been loaded automatically and no loaded modules require it anymore. # unmodlist: pass a list of modules that are going to be unloaded proc isModuleUnloadable {mod {unmodlist {}}} { set ret 1 # get currently unloading modules if no specific unmodlist set if {[llength $unmodlist] == 0} { set unmodlist [getUnloadingModuleList] } if {[isModuleUserAsked $mod]} { set ret 0 } else { # mod is unloadable if all its dependent are unloaded or unloading foreach depmod [getDirectDependentList $mod] { if {[notInList $unmodlist $depmod]} { set ret 0 break } } } return $ret } # gets the list of all loaded modules which are required by passed modlist # ordered by load position. proc getRequiredLoadedModuleList {modlist} { reportDebug "get mods required by '$modlist'" # search over all list of loaded modules, starting with passed module # list, then adding in turns their requirements set fulllist $modlist for {set i 0} {$i < [llength $fulllist]} {incr i 1} { # gets the list of loaded modules which are required by depmod eval appendNoDupToList fulllist $::g_moduleDepend([lindex $fulllist $i]) } # sort complete result list to match both loaded and dependency orders set sortlist [sortModulePerLoadedAndDepOrder [lrange $fulllist [llength\ $modlist] end]] reportDebug "got '$sortlist'" return $sortlist } # finds required modules that can be unloaded if passed modules are unloaded: # they have been loaded automatically and are not depended (mandatory or # optionally) by other module proc getUnloadableLoadedModuleList {modlist} { reportDebug "get unloadable mods once '$modlist' unloaded" # search over all list of unloaded modules, starting with passed module # list, then adding in turns unloadable requirements set fulllist $modlist for {set i 0} {$i < [llength $fulllist]} {incr i 1} { set depmod [lindex $fulllist $i] # gets the list of loaded modules which are required by depmod set deplist {} foreach lmmodlist $::g_moduleDepend($depmod) { foreach lmmod $lmmodlist { if {[notInList $fulllist $lmmod]} { lappend deplist $lmmod } } } # get those required module that have been automatically loaded and are # only required by modules currently being unloaded foreach lmmod $deplist { if {[isModuleUnloadable $lmmod $fulllist]} { lappend fulllist $lmmod } } } # sort complete result list to match both loaded and dependency orders set sortlist [sortModulePerLoadedAndDepOrder [lrange $fulllist [llength\ $modlist] end]] reportDebug "got '$sortlist'" return $sortlist } # runs the global RC files if they exist proc runModulerc {} { set rclist {} reportDebug running... if {[set rcfile [getConf rcfile]] ne {}} { # if MODULERCFILE is a dir, look at a modulerc file in it if {[file isdirectory $rcfile]\ && [file isfile $rcfile/modulerc]} { lappend rclist $rcfile/modulerc } elseif {[file isfile $rcfile]} { lappend rclist $rcfile } } if {[file isfile /etc/environment-modules/rc]} { lappend rclist /etc/environment-modules/rc } if {[info exists ::env(HOME)] && [file isfile $::env(HOME)/.modulerc]} { lappend rclist $::env(HOME)/.modulerc } foreach rc $rclist { if {[file readable $rc]} { reportDebug "Executing $rc" cmdModuleSource $rc lappend ::g_rc_loaded $rc } } # identify alias or symbolic version set in these global RC files to be # able to include them or not in output or resolution processes array set ::g_rcAlias [array get ::g_moduleAlias] array set ::g_rcVersion [array get ::g_moduleVersion] array set ::g_rcVirtual [array get ::g_moduleVirtual] } # how many settings bundle are currently saved proc getSavedSettingsStackDepth {} { return [llength $::g_SAVE_g_loadedModules] } # manage settings to save as a stack to have a separate set of settings # for each module loaded or unloaded in order to be able to restore the # correct set in case of failure proc pushSettings {} { foreach var {env g_clearedEnvVars g_Aliases g_stateEnvVars g_stateAliases\ g_stateFunctions g_Functions g_newXResources g_delXResources\ g_loadedModules g_loadedModuleFiles g_loadedModuleUasked\ g_loadedModuleConflict g_loadedModulePrereq g_loadedModuleAltname\ g_loadedModuleAutoAltname g_moduleDepend g_dependHash g_moduleNPODepend\ g_dependNPOHash g_prereqViolation g_prereqNPOViolation\ g_conflictViolation g_moduleUnmetDep g_unmetDepHash g_moduleEval} { eval "lappend ::g_SAVE_$var \[array get ::$var\]" } # save non-array variable and indication if it was set foreach var {g_changeDir g_stdoutPuts g_return_text} { if {[info exists ::$var]} { eval "lappend ::g_SAVE_$var \[list 1 \[set ::$var\]\]" } else { eval "lappend ::g_SAVE_$var \[list 0 {}\]" } } reportDebug "settings saved (#[getSavedSettingsStackDepth])" } proc popSettings {} { set flushedid [getSavedSettingsStackDepth] foreach var {env g_clearedEnvVars g_Aliases g_stateEnvVars g_stateAliases\ g_stateFunctions g_Functions g_newXResources g_delXResources\ g_changeDir g_stdoutPuts g_return_text\ g_loadedModules g_loadedModuleFiles g_loadedModuleUasked\ g_loadedModuleConflict g_loadedModulePrereq g_loadedModuleAltname\ g_loadedModuleAutoAltname g_moduleDepend g_dependHash g_moduleNPODepend\ g_dependNPOHash g_prereqViolation g_prereqNPOViolation\ g_conflictViolation g_moduleUnmetDep g_unmetDepHash g_moduleEval} { eval "set ::g_SAVE_$var \[lrange \$::g_SAVE_$var 0 end-1\]" } reportDebug "previously saved settings flushed (#$flushedid)" } proc restoreSettings {} { foreach var {g_clearedEnvVars g_Aliases g_stateEnvVars g_stateAliases\ g_stateFunctions g_Functions g_newXResources g_delXResources\ g_loadedModules g_loadedModuleFiles g_loadedModuleUasked\ g_loadedModuleConflict g_loadedModulePrereq g_loadedModuleAltname\ g_loadedModuleAutoAltname g_moduleDepend g_dependHash g_moduleNPODepend\ g_dependNPOHash g_prereqViolation g_prereqNPOViolation\ g_conflictViolation g_moduleUnmetDep g_unmetDepHash g_moduleEval} { # clear current $var arrays if {[info exists ::$var]} { eval "unset ::$var; array set ::$var {}" } eval "array set ::$var \[lindex \$::g_SAVE_$var end\]" } # specific restore mechanism for ::env as unsetting this array will make # Tcl stop monitoring env accesses and not update env variables anymore set envvarlist [list] foreach {var val} [lindex $::g_SAVE_env end] { lappend envvarlist $var interp-sync-env set $var $val } foreach var [array names ::env] { if {[notInList $envvarlist $var]} { interp-sync-env unset $var } } # restore non-array variable if it was set foreach var {g_changeDir g_stdoutPuts g_return_text} { if {[info exists ::$var]} { eval "unset ::$var" } eval "lassign \[lindex \$::g_SAVE_$var end\] isdefined val" if {$isdefined} { set ::$var $val } } reportDebug "previously saved settings restored\ (#[getSavedSettingsStackDepth])" } proc renderSettings {} { global g_stateEnvVars g_stateAliases g_stateFunctions g_newXResources\ g_delXResources reportDebug called. # required to work on cygwin, shouldn't hurt real linux fconfigure stdout -translation lf # preliminaries if there is stuff to render if {$::g_autoInit || [array size g_stateEnvVars] > 0 ||\ [array size g_stateAliases] > 0 || [array size g_newXResources] > 0 ||\ [array size g_stateFunctions] > 0 || [array size g_delXResources] > 0\ || [info exists ::g_changeDir] || [info exists ::g_stdoutPuts] ||\ [info exists ::g_return_text]} { switch -- $::g_shellType { python { puts stdout {import os} } } set has_rendered 1 } else { set has_rendered 0 } if {$::g_autoInit} { renderAutoinit } # new environment variables foreach var [array names g_stateEnvVars] { switch -- $g_stateEnvVars($var) { new { switch -- $::g_shellType { csh { set val [charEscaped $::env($var)] # csh barfs on long env vars if {$::g_shell eq {csh} && [string length $val] >\ $::CSH_LIMIT} { if {$var eq {PATH}} { reportWarning "PATH exceeds $::CSH_LIMIT characters,\ truncating and appending /usr/bin:/bin ..." set val [string range $val 0 [expr {$::CSH_LIMIT\ - 1}]]:/usr/bin:/bin } else { reportWarning "$var exceeds $::CSH_LIMIT characters,\ truncating..." set val [string range $val 0 [expr {$::CSH_LIMIT\ - 1}]] } } puts stdout "setenv $var $val;" } sh { puts stdout "$var=[charEscaped $::env($var)];\ export $var;" } fish { set val [charEscaped $::env($var)] # fish shell has special treatment for PATH variable # so its value should be provided as a list separated # by spaces not by semi-colons if {$var eq {PATH}} { regsub -all : $val { } val } puts stdout "set -xg $var $val;" } tcl { set val $::env($var) puts stdout "set ::env($var) {$val};" } cmd { set val $::env($var) puts stdout "set $var=$val" } perl { set val [charEscaped $::env($var) \'] puts stdout "\$ENV{'$var'} = '$val';" } python { set val [charEscaped $::env($var) \'] puts stdout "os.environ\['$var'\] = '$val'" } ruby { set val [charEscaped $::env($var) \'] puts stdout "ENV\['$var'\] = '$val'" } lisp { set val [charEscaped $::env($var) \"] puts stdout "(setenv \"$var\" \"$val\")" } cmake { set val [charEscaped $::env($var) \"] puts stdout "set(ENV{$var} \"$val\")" } r { set val [charEscaped $::env($var) {\\'}] puts stdout "Sys.setenv('$var'='$val')" } } } del { switch -- $::g_shellType { csh { puts stdout "unsetenv $var;" } sh { puts stdout "unset $var;" } fish { puts stdout "set -e $var;" } tcl { puts stdout "catch {unset ::env($var)};" } cmd { puts stdout "set $var=" } perl { puts stdout "delete \$ENV{'$var'};" } python { puts stdout "os.environ\['$var'\] = ''" puts stdout "del os.environ\['$var'\]" } ruby { puts stdout "ENV\['$var'\] = nil" } lisp { puts stdout "(setenv \"$var\" nil)" } cmake { puts stdout "unset(ENV{$var})" } r { puts stdout "Sys.unsetenv('$var')" } } } } } foreach var [array names g_stateAliases] { switch -- $g_stateAliases($var) { new { set val $::g_Aliases($var) # convert $n in !!:n and $* in !* on csh (like on compat version) if {$::g_shellType eq {csh}} { regsub -all {([^\\]|^)\$([0-9]+)} $val {\1!!:\2} val regsub -all {([^\\]|^)\$\*} $val {\1!*} val } # unescape \$ after now csh-specific conversion is over regsub -all {\\\$} $val {$} val switch -- $::g_shellType { csh { set val [charEscaped $val] puts stdout "alias $var $val;" } sh { set val [charEscaped $val] puts stdout "alias $var=$val;" } fish { set val [charEscaped $val] puts stdout "alias $var $val;" } cmd { puts stdout "doskey $var=$val" } } } del { switch -- $::g_shellType { csh { puts stdout "unalias $var;" } sh { puts stdout "unalias $var;" } fish { puts stdout "functions -e $var;" } cmd { puts stdout "doskey $var=" } } } } } foreach funcname [array names g_stateFunctions] { switch -- $g_stateFunctions($funcname) { new { # trim function body to smoothly add a finishing ; set val [string trim $::g_Functions($funcname) "; \t\n\r"] switch -- $::g_shellType { sh { puts stdout "$funcname () { $val; }; export $funcname;" } fish { puts stdout "function $funcname; $val; end;" } } } del { switch -- $::g_shellType { sh { puts stdout "unset -f $funcname;" } fish { puts stdout "functions -e $funcname;" } } } } } # preliminaries for x-resources stuff if {[array size g_newXResources] > 0 || [array size g_delXResources] > 0} { switch -- $::g_shellType { python { puts stdout {import subprocess} } ruby { puts stdout {require 'open3'} } } } # new x resources if {[array size g_newXResources] > 0} { # xrdb executable has already be verified in x-resource set xrdb [getCommandPath xrdb] foreach var [array names g_newXResources] { set val $g_newXResources($var) # empty val means that var is a file to parse if {$val eq {}} { switch -- $::g_shellType { sh - csh - fish { puts stdout "$xrdb -merge $var;" } tcl { puts stdout "exec $xrdb -merge $var;" } perl { puts stdout "system(\"$xrdb -merge $var\");" } python { set var [charEscaped $var \'] puts stdout "subprocess.Popen(\['$xrdb',\ '-merge', '$var'\])" } ruby { set var [charEscaped $var \'] puts stdout "Open3.popen2('$xrdb -merge $var')" } lisp { puts stdout "(shell-command-to-string \"$xrdb\ -merge $var\")" } cmake { puts stdout "execute_process(COMMAND $xrdb -merge $var)" } r { set var [charEscaped $var {\\'}] puts stdout "system('$xrdb -merge $var')" } } } else { switch -- $::g_shellType { sh - csh - fish { set var [charEscaped $var \"] set val [charEscaped $val \"] puts stdout "echo \"$var: $val\" | $xrdb -merge;" } tcl { puts stdout "set XRDBPIPE \[open \"|$xrdb -merge\" r+\];" set var [charEscaped $var \"] set val [charEscaped $val \"] puts stdout "puts \$XRDBPIPE \"$var: $val\";" puts stdout {close $XRDBPIPE;} puts stdout {unset XRDBPIPE;} } perl { puts stdout "open(XRDBPIPE, \"|$xrdb -merge\");" set var [charEscaped $var \"] set val [charEscaped $val \"] puts stdout "print XRDBPIPE \"$var: $val\\n\";" puts stdout {close XRDBPIPE;} } python { set var [charEscaped $var \'] set val [charEscaped $val \'] puts stdout "subprocess.Popen(\['$xrdb', '-merge'\],\ stdin=subprocess.PIPE).communicate(input='$var:\ $val\\n')" } ruby { set var [charEscaped $var \'] set val [charEscaped $val \'] puts stdout "Open3.popen2('$xrdb -merge') {|i,o,t| i.puts\ '$var: $val'}" } lisp { puts stdout "(shell-command-to-string \"echo $var:\ $val | $xrdb -merge\")" } cmake { set var [charEscaped $var \"] set val [charEscaped $val \"] puts stdout "execute_process(COMMAND echo \"$var: $val\"\ COMMAND $xrdb -merge)" } r { set var [charEscaped $var {\\'}] set val [charEscaped $val {\\'}] puts stdout "system('$xrdb -merge', input='$var: $val')" } } } } } if {[array size g_delXResources] > 0} { set xrdb [getCommandPath xrdb] set xres_to_del {} foreach var [array names g_delXResources] { # empty val means that var is a file to parse if {$g_delXResources($var) eq {}} { # xresource file has to be parsed to find what resources # are declared there and need to be unset foreach fline [split [exec $xrdb -n load $var] \n] { lappend xres_to_del [lindex [split $fline :] 0] } } else { lappend xres_to_del $var } } # xresource strings are unset by emptying their value since there # is no command of xrdb that can properly remove one property switch -- $::g_shellType { sh - csh - fish { foreach var $xres_to_del { puts stdout "echo \"$var:\" | $xrdb -merge;" } } tcl { foreach var $xres_to_del { puts stdout "set XRDBPIPE \[open \"|$xrdb -merge\" r+\];" set var [charEscaped $var \"] puts stdout "puts \$XRDBPIPE \"$var:\";" puts stdout {close $XRDBPIPE;} puts stdout {unset XRDBPIPE;} } } perl { foreach var $xres_to_del { puts stdout "open(XRDBPIPE, \"|$xrdb -merge\");" set var [charEscaped $var \"] puts stdout "print XRDBPIPE \"$var:\\n\";" puts stdout {close XRDBPIPE;} } } python { foreach var $xres_to_del { set var [charEscaped $var \'] puts stdout "subprocess.Popen(\['$xrdb', '-merge'\],\ stdin=subprocess.PIPE).communicate(input='$var:\\n')" } } ruby { foreach var $xres_to_del { set var [charEscaped $var \'] puts stdout "Open3.popen2('$xrdb -merge') {|i,o,t| i.puts\ '$var:'}" } } lisp { foreach var $xres_to_del { puts stdout "(shell-command-to-string \"echo $var: |\ $xrdb -merge\")" } } cmake { foreach var $xres_to_del { set var [charEscaped $var \"] puts stdout "execute_process(COMMAND echo \"$var:\"\ COMMAND $xrdb -merge)" } } r { foreach var $xres_to_del { set var [charEscaped $var {\\'}] puts stdout "system('$xrdb -merge', input='$var:')" } } } } if {[info exists ::g_changeDir]} { switch -- $::g_shellType { sh - csh - fish { puts stdout "cd '$::g_changeDir';" } tcl { puts stdout "cd \"$::g_changeDir\";" } cmd { puts stdout "cd $::g_changeDir" } perl { puts stdout "chdir '$::g_changeDir';" } python { puts stdout "os.chdir('$::g_changeDir')" } ruby { puts stdout "Dir.chdir('$::g_changeDir')" } lisp { puts stdout "(shell-command-to-string \"cd '$::g_changeDir'\")" } r { puts stdout "setwd('$::g_changeDir')" } } # cannot change current directory of cmake "shell" } # send content deferred during modulefile interpretation if {[info exists ::g_stdoutPuts]} { foreach putsArgs $::g_stdoutPuts { eval puts $putsArgs # check if a finishing newline will be needed after content sent set needPutsNl [expr {[lindex $putsArgs 0] eq {-nonewline} ? 1 : 0}] } if {$needPutsNl} { puts stdout {} } } # return text value if defined even if error happened if {[info exists ::g_return_text]} { reportDebug {text value should be returned.} renderText $::g_return_text } elseif {$::error_count > 0} { reportDebug "$::error_count error(s) detected." renderFalse } elseif {$::g_return_false} { reportDebug {false value should be returned.} renderFalse } elseif {$has_rendered} { # finish with true statement if something has been put renderTrue } } proc renderAutoinit {} { reportDebug called. # automatically detect which tclsh should be used for # future module commands set tclshbin [info nameofexecutable] # ensure script path is absolute set ::argv0 [getAbsolutePath $::argv0] switch -- $::g_shellType { csh { set pre_hi {set _histchars = $histchars; unset histchars;} set post_hi {set histchars = $_histchars; unset _histchars;} set pre_pr {set _prompt=$prompt:q; set prompt="";} set post_pr {set prompt=$_prompt:q; unset _prompt;} # apply workaround for Tcsh history if set set eval_cmd [expr {[getConf wa_277] ? "eval `$tclshbin $::argv0\ $::g_shell \\!*`;" : "eval \"`$tclshbin $::argv0 $::g_shell\ \\!*:q`\";"}] set pre_ex {set _exit="$status";} set post_ex {test 0 = $_exit} set fdef "if ( \$?histchars && \$?prompt )\ alias module '$pre_hi $pre_pr $eval_cmd $pre_ex $post_hi $post_pr $post_ex' ; if ( \$?histchars && ! \$?prompt )\ alias module '$pre_hi $eval_cmd $pre_ex $post_hi $post_ex' ; if ( ! \$?histchars && \$?prompt )\ alias module '$pre_pr $eval_cmd $pre_ex $post_pr $post_ex' ; if ( ! \$?histchars && ! \$?prompt ) alias module '$eval_cmd' ;" if {[getConf ml]} { append fdef { alias ml 'module ml \!*' ;} } } sh { # Considering the diversity of ways local variables are handled # through the sh-variants ('local' known everywhere except on ksh, # 'typeset' known everywhere except on pure-sh, and on some systems # the pure-sh is in fact a 'ksh'), no local variables are defined and # these variables that should have been local are unset at the end # on zsh, word splitting should be enabled explicitly set wsplit [expr {$::g_shell eq {zsh} ? {=} : {}}] # only redirect module from stderr to stdout when session is # attached to a terminal to avoid breaking non-terminal session # (scp, sftp, etc) set fname [expr {[isStderrTty] ? {_module_raw} : {module}}] # build quarantine mechanism in module function # an empty runtime variable is set even if no corresponding # MODULES_RUNENV_* variable found, as var cannot be unset on # modified environment command-line set fdef "${fname}() {" append fdef { unset _mlshdbg; if [ "${MODULES_SILENT_SHELL_DEBUG:-0}" = '1' ]; then case "$-" in *v*x*) set +vx; _mlshdbg='vx' ;; *v*) set +v; _mlshdbg='v' ;; *x*) set +x; _mlshdbg='x' ;; *) _mlshdbg='' ;; esac; fi;} append fdef " unset _mlre _mlIFS; if \[ -n \"\${IFS+x}\" \]; then _mlIFS=\$IFS; fi; IFS=' '; for _mlv in \${${wsplit}MODULES_RUN_QUARANTINE:-}; do" append fdef { if [ "${_mlv}" = "${_mlv##*[!A-Za-z0-9_]}" -a "${_mlv}" = "${_mlv#[0-9]}" ]; then if [ -n "`eval 'echo ${'$_mlv'+x}'`" ]; then _mlre="${_mlre:-}${_mlv}_modquar='`eval 'echo ${'$_mlv'}'`' "; fi; _mlrv="MODULES_RUNENV_${_mlv}"; _mlre="${_mlre:-}${_mlv}='`eval 'echo ${'$_mlrv':-}'`' "; fi; done; if [ -n "${_mlre:-}" ]; then} append fdef "\n eval `eval \${${wsplit}_mlre} $tclshbin $::argv0\ $::g_shell '\"\$@\"'`; else eval `$tclshbin $::argv0 $::g_shell \"\$@\"`; fi;" # append fdef " # eval `$tclshbin $::argv0 $::g_shell \"\$@\"`;" append fdef { _mlstatus=$?;} append fdef { if [ -n "${_mlIFS+x}" ]; then IFS=$_mlIFS; else unset IFS; fi; unset _mlre _mlv _mlrv _mlIFS;} append fdef { if [ -n "${_mlshdbg:-}" ]; then set -$_mlshdbg; fi; unset _mlshdbg;} append fdef { return $_mlstatus;} append fdef "\n};" if {[isStderrTty]} { append fdef "\nmodule() { _module_raw \"\$@\" 2>&1; };" } if {[getConf ml]} { append fdef { ml() { module ml "$@"; };} } } fish { set fdef [expr {[isStderrTty] ? "function _module_raw\n" :\ "function module\n"}] append fdef { set -l _mlre ''; set -l _mlv; set -l _mlrv; for _mlv in (string split ' ' $MODULES_RUN_QUARANTINE) if string match -r '^[A-Za-z_][A-Za-z0-9_]*$' $_mlv >/dev/null if set -q $_mlv set _mlre $_mlre$_mlv"_modquar='$$_mlv' " end set _mlrv "MODULES_RUNENV_$_mlv" set _mlre "$_mlre$_mlv='$$_mlrv' " end end if [ -n "$_mlre" ] set _mlre "env $_mlre" end} # use "| source -" rather than "eval" to be able # to redirect stderr after stdout being evaluated append fdef "\n eval \$_mlre $tclshbin $::argv0 $::g_shell\ (string escape -- \$argv) | source -\n" # append fdef " eval $tclshbin $::argv0 $::g_shell\ (string escape -- \$argv) | source -\n" if {[isStderrTty]} { append fdef {end function module _module_raw $argv 2>&1 end} } else { append fdef end } if {[getConf ml]} { append fdef { function ml module ml $argv end} } } tcl { set fdef "proc module {args} {" append fdef { set _mlre {}; if {[info exists ::env(MODULES_RUN_QUARANTINE)]} { foreach _mlv [split $::env(MODULES_RUN_QUARANTINE) " "] { if {[regexp {^[A-Za-z_][A-Za-z0-9_]*$} $_mlv]} { if {[info exists ::env($_mlv)]} { lappend _mlre "${_mlv}_modquar=$::env($_mlv)" } set _mlrv "MODULES_RUNENV_${_mlv}" lappend _mlre [expr {[info exists ::env($_mlrv)] ?\ "${_mlv}=$::env($_mlrv)" : "${_mlv}="}] } } if {[llength $_mlre] > 0} { set _mlre [linsert $_mlre 0 "env"] } }} append fdef { set _mlstatus 1;} append fdef "\n catch {eval exec \$_mlre \"$tclshbin\"\ \"$::argv0\" \"$::g_shell\" \$args 2>@stderr} script\n" # append fdef "\n catch {eval exec \"$tclshbin\"\ \"$::argv0\" \"$::g_shell\" \$args 2>@stderr} script\n" append fdef { eval $script; return $_mlstatus} append fdef "\n}" if {[getConf ml]} { append fdef { proc ml {args} { return [eval module ml $args] }} } } cmd { reportErrorAndExit {No autoinit mode available for 'cmd' shell} } perl { set fdef "sub module {" append fdef { my $_mlre = ''; if (defined $ENV{'MODULES_RUN_QUARANTINE'}) { foreach my $_mlv (split(' ', $ENV{'MODULES_RUN_QUARANTINE'})) { if ($_mlv =~ /^[A-Za-z_][A-Za-z0-9_]*$/) { if (defined $ENV{$_mlv}) { $_mlre .= "${_mlv}_modquar='$ENV{$_mlv}' "; } my $_mlrv = "MODULES_RUNENV_$_mlv"; $_mlre .= "$_mlv='$ENV{$_mlrv}' "; } } if ($_mlre ne "") { $_mlre = "env $_mlre"; } }} append fdef { my $args = ''; if (@_ > 0) { $args = '"' . join('" "', @_) . '"'; } my $_mlstatus = 1;} append fdef "\n eval `\${_mlre}$tclshbin $::argv0 perl \$args`;\n" # append fdef "\n eval `$tclshbin $::argv0 perl \$args`;\n" append fdef { return $_mlstatus;} append fdef "\n}" if {[getConf ml]} { append fdef { sub ml { return module('ml', @_); }} } } python { set fdef {import re, subprocess def module(*arguments):} append fdef { _mlre = os.environ.copy() if 'MODULES_RUN_QUARANTINE' in os.environ: for _mlv in os.environ['MODULES_RUN_QUARANTINE'].split(): if re.match('^[A-Za-z_][A-Za-z0-9_]*$', _mlv): if _mlv in os.environ: _mlre[_mlv + '_modquar'] = os.environ[_mlv] _mlrv = 'MODULES_RUNENV_' + _mlv if _mlrv in os.environ: _mlre[_mlv] = os.environ[_mlrv] else: _mlre[_mlv] = ''} append fdef { ns = {}} append fdef "\n exec(subprocess.Popen(\['$tclshbin',\ '$::argv0', 'python'\] + list(arguments),\ stdout=subprocess.PIPE, env=_mlre).communicate()\[0\], ns)\n" # append fdef "\n exec(subprocess.Popen(\['$tclshbin',\ '$::argv0', 'python'\] + list(arguments),\ stdout=subprocess.PIPE).communicate()\[0\], ns)\n" append fdef { if '_mlstatus' in ns: _mlstatus = ns['_mlstatus'] else: _mlstatus = True return _mlstatus} if {[getConf ml]} { append fdef { def ml(*arguments): return module('ml', *arguments) } } } ruby { set fdef {class ENVModule def ENVModule.module(*args)} append fdef { _mlre = '' if ENV.has_key?('MODULES_RUN_QUARANTINE') then ENV['MODULES_RUN_QUARANTINE'].split(' ').each do |_mlv| if _mlv =~ /^[A-Za-z_][A-Za-z0-9_]*$/ then if ENV.has_key?(_mlv) then _mlre << _mlv + "_modquar='" + ENV[_mlv].to_s + "' " end _mlrv = 'MODULES_RUNENV_' + _mlv _mlre << _mlv + "='" + ENV[_mlrv].to_s + "' " end end unless _mlre.empty? _mlre = 'env ' + _mlre end end} append fdef { if args[0].kind_of?(Array) then args = args[0] end if args.length == 0 then args = '' else args = "\"#{args.join('" "')}\"" end _mlstatus = true} append fdef "\n eval `#{_mlre}$tclshbin $::argv0 ruby #{args}`\n" # append fdef "\n eval `$tclshbin $::argv0 ruby #{args}`\n" append fdef { return _mlstatus end} if {[getConf ml]} { append fdef { def ENVModule.ml(*args) return ENVModule.module('ml', *args) end} } append fdef { end} } lisp { reportErrorAndExit {lisp mode autoinit not yet implemented} } cmake { set pre_exec "\n execute_process(COMMAND \${_mlre} $tclshbin\ $::argv0 cmake " # set pre_exec "\n execute_process(COMMAND $tclshbin\ $::argv0 cmake " set post_exec "\n OUTPUT_FILE \${tempfile_name})\n" set fdef {function(module) cmake_policy(SET CMP0007 NEW)} append fdef { set(_mlre "") if(DEFINED ENV{MODULES_RUN_QUARANTINE}) string(REPLACE " " ";" _mlv_list "$ENV{MODULES_RUN_QUARANTINE}") foreach(_mlv ${_mlv_list}) if(${_mlv} MATCHES "^[A-Za-z_][A-Za-z0-9_]*$") if(DEFINED ENV{${_mlv}}) set(_mlre "${_mlre}${_mlv}_modquar=$ENV{${_mlv}};") endif() set(_mlrv "MODULES_RUNENV_${_mlv}") set(_mlre "${_mlre}${_mlv}=$ENV{${_mlrv}};") endif() endforeach() if (NOT "${_mlre}" STREQUAL "") set(_mlre "env;${_mlre}") endif() endif()} append fdef { set(_mlstatus TRUE) execute_process(COMMAND mktemp -t moduleinit.cmake.XXXXXXXXXXXX OUTPUT_VARIABLE tempfile_name OUTPUT_STRIP_TRAILING_WHITESPACE) if(${ARGC} EQUAL 1)} # adapt command definition depending on the number of args to be # able to pass to some extend (<5 args) empty string element to # modulecmd (no other way as empty element in ${ARGV} are skipped append fdef "$pre_exec\"\${ARGV0}\"$post_exec" append fdef { elseif(${ARGC} EQUAL 2)} append fdef "$pre_exec\"\${ARGV0}\" \"\${ARGV1}\"$post_exec" append fdef { elseif(${ARGC} EQUAL 3)} append fdef "$pre_exec\"\${ARGV0}\" \"\${ARGV1}\"\ \"\${ARGV2}\"$post_exec" append fdef { elseif(${ARGC} EQUAL 4)} append fdef "$pre_exec\"\${ARGV0}\" \"\${ARGV1}\"\ \"\${ARGV2}\" \"\${ARGV3}\"$post_exec" append fdef { else()} append fdef "$pre_exec\${ARGV}$post_exec" append fdef { endif() if(EXISTS ${tempfile_name}) include(${tempfile_name}) file(REMOVE ${tempfile_name}) endif() set(module_result ${_mlstatus} PARENT_SCOPE) endfunction(module)} if {[getConf ml]} { append fdef { function(ml) module(ml ${ARGV}) set(module_result ${module_result} PARENT_SCOPE) endfunction(ml)} } } r { set fdef "module <- function(...){" append fdef { mlre <- '' if (!is.na(Sys.getenv('MODULES_RUN_QUARANTINE', unset=NA))) { for (mlv in strsplit(Sys.getenv('MODULES_RUN_QUARANTINE'), ' ')[[1]]) { if (grepl('^[A-Za-z_][A-Za-z0-9_]*$', mlv)) { if (!is.na(Sys.getenv(mlv, unset=NA))) { mlre <- paste0(mlre, mlv, "_modquar='", Sys.getenv(mlv), "' ") } mlrv <- paste0('MODULES_RUNENV_', mlv) mlre <- paste0(mlre, mlv, "='", Sys.getenv(mlrv), "' ") } } if (mlre != '') { mlre <- paste0('env ', mlre) } }} append fdef { arglist <- as.list(match.call()) arglist[1] <- 'r' args <- paste0('"', paste0(arglist, collapse='" "'), '"')} append fdef "\n cmd <- paste(mlre, '$tclshbin', '$::argv0', args,\ sep=' ')\n" # append fdef "\n cmd <- paste('$tclshbin', '$::argv0', args,\ sep=' ')\n" append fdef { mlstatus <- TRUE hndl <- pipe(cmd) eval(expr = parse(file=hndl)) close(hndl) invisible(mlstatus)} append fdef "\n}" if {[getConf ml]} { append fdef { ml <- function(...){ module('ml', ...) }} } } } # output function definition puts stdout $fdef } proc cacheCurrentModules {} { # parse loaded modules information only once, global arrays are updated # afterwards when module commands update loaded modules state if {![info exists ::g_lm_info_cached]} { set ::g_lm_info_cached 1 # mark specific as well as generic modules as loaded set i 0 set modfilelist [getLoadedModuleFileList] set modlist [getLoadedModuleList] set nuaskedlist [getLoadedModuleNotUserAskedList] if {[llength $modlist] == [llength $modfilelist]} { # cache declared alternative names of loaded modules foreach modalt [getLoadedModuleAltnameList] { eval setLoadedAltname $modalt } # cache declared conflict of loaded modules foreach modcon [getLoadedModuleConflictList] { # parse module version specification to record translation foreach modconelt [lrange $modcon 1 end] { eval parseModuleVersionSpecifier 0 $modconelt } eval setLoadedConflict $modcon } # cache declared prereq of loaded modules, prior to setLoadedModule # which triggers dependency chain build foreach modpre [getLoadedModulePrereqList] { # parse module version specification to record translation foreach modpreeltlist [lrange $modpre 1 end] { foreach modpreelt $modpreeltlist { eval parseModuleVersionSpecifier 0 $modpreelt } } eval setLoadedPrereq $modpre } foreach mod $modlist { setLoadedModule $mod [lindex $modfilelist $i] [notInList\ $nuaskedlist $mod] incr i } reportDebug "$i loaded" } else { reportErrorAndExit "Loaded environment state is\ inconsistent\nLOADEDMODULES=$modlist\n_LMFILES_=$modfilelist" } } } # This proc resolves module aliases or version aliases to the real module name # and version. proc resolveModuleVersionOrAlias {name icase} { set name [getArrayKey ::g_moduleResolved $name $icase] if {[info exists ::g_moduleResolved($name)]} { set ret $::g_moduleResolved($name) } else { set ret $name } reportDebug "'$name' resolved to '$ret'" return $ret } proc charEscaped {str {charlist { \\\t\{\}|<>!;#^$&*?"'`()}}} { return [regsub -all "\(\[$charlist\]\)" $str {\\\1}] } proc charUnescaped {str {charlist { \\\t\{\}|<>!;#^$&*?"'`()}}} { return [regsub -all "\\\\\(\[$charlist\]\)" $str {\1}] } # find command path and remember it proc getCommandPath {cmd} { return [lindex [auto_execok $cmd] 0] } # find then run command or raise error if command not found proc runCommand {cmd args} { set cmdpath [getCommandPath $cmd] if {$cmdpath eq {}} { knerror "Command '$cmd' cannot be found" MODULES_ERR_GLOBAL } else { return [eval exec $cmdpath $args] } } proc getAbsolutePath {path} { # currently executing a modulefile or rc, so get the directory of this file if {$::ModulesCurrentModulefile ne {}} { set curdir [file dirname $::ModulesCurrentModulefile] # elsewhere get module command current working directory } else { # register pwd at first call if {![info exists ::cwd]} { set ::cwd [pwd] } set curdir $::cwd } # empty result if empty path if {$path eq {}} { set abspath {} } else { set abslist {} # get a first version of the absolute path by joining the current # working directory to the given path. if given path is already absolute # 'file join' will not break it as $curdir will be ignored as soon a # beginning '/' character is found on $path. this first pass also clean # extra '/' character. then each element of the path is analyzed to # clear "." and ".." components. foreach elt [file split [file join $curdir $path]] { if {$elt eq {..}} { # skip ".." element if it comes after root element, remove last # element elsewhere if {[llength $abslist] > 1} { set abslist [lreplace $abslist end end] } # skip any "." element } elseif {$elt ne {.}} { lappend abslist $elt } } set abspath [eval file join $abslist] } # return cleaned absolute path return $abspath } # if no exact match found but icase mode is enabled then search if an icase # match exists among all array key elements, select dictionary highest version # if multiple icase matches are returned proc getArrayKey {arrname name icase} { if {$icase} { upvar $arrname arr if {![info exists arr($name)]} { foreach elt [lsort -dictionary -decreasing [array names arr]] { if {[string equal -nocase $name $elt]} { reportDebug "key '$elt' in array '$arrname' matches '$name'" set name $elt break } } } } return $name } # Define procedure to compare module names set as array keys against pattern. # Adapt procedure code whether implicit_default is enabled or disabled proc defineGetEqArrayKeyProc {icase extdfl impdfl} { set procname getEqArrayKeyProc if {$impdfl} { append procname Impdfl } # define proc if not done yet or if it was defined for another context if {[info procs getEqArrayKey] eq {} || $::g_getEqArrayKey_proc ne\ $procname} { if {[info exists ::g_getEqArrayKey_proc]} { rename ::getEqArrayKey ::$::g_getEqArrayKey_proc } rename ::$procname ::getEqArrayKey set ::g_getEqArrayKey_proc $procname } # also define modEq which is called by getEqArrayKey defineModEqProc $icase $extdfl } # alternative definitions of getEqArrayKey proc proc getEqArrayKeyProcImpdfl {arrname name} { set icase [isIcase] upvar $arrname arr # extract single module specified if any lassign [getModuleVersSpec $name] mod modname # check name eventual icase match set mod [getArrayKey arr [string trimright $mod /] $icase] if {$mod ne {} && [info exists arr($mod)]} { set match $mod } else { set mlist {} foreach elt [array names arr] { if {[modEq $name $elt]} { lappend mlist $elt } } if {[llength $mlist] == 1} { set match [lindex $mlist 0] # in case multiple modules match query, check directory default and # return it if it is part of match list, elsewhere return highest result } elseif {[llength $mlist] > 1} { # get corresponding icase parent directory set pname [getArrayKey arr $modname $icase] if {[info exists arr($pname)]} { set dfl $pname/[lindex $arr($pname) 1] } # resolve symbolic version entries foreach elt $mlist { if {[lindex $arr($elt) 0] eq {version}} { lappend mrlist [lindex $arr($elt) 1] } else { lappend mrlist $elt } } if {[info exists dfl] && [isInList $mrlist $dfl]} { set match $dfl } else { set match [lindex [lsort -dictionary $mrlist] end] } } } if {[info exists match]} { reportDebug "key '$match' in array '$arrname' matches '$name'" set name $match } return $name } proc getEqArrayKeyProc {arrname name} { set icase [isIcase] upvar $arrname arr lassign [getModuleVersSpec $name] mod modname # check name eventual icase match set mod [getArrayKey arr [string trimright $mod /] $icase] if {$mod ne {} && [info exists arr($mod)]} { set match $mod } else { set mlist {} foreach elt [array names arr] { if {[modEq $name $elt]} { lappend mlist $elt } } # must have a default part of result even if only one result if {[llength $mlist] >= 1} { # get corresponding icase parent directory set pname [getArrayKey arr $modname $icase] if {[info exists arr($pname)]} { set dfl $pname/[lindex $arr($pname) 1] } # resolve symbolic version entries foreach elt $mlist { if {[lindex $arr($elt) 0] eq {version}} { lappend mrlist [lindex $arr($elt) 1] } else { lappend mrlist $elt } } if {[info exists dfl] && [isInList $mrlist $dfl]} { set match $dfl } else { # raise error as no default part of result upvar retlist retlist set retlist [list {} $name none "No default version\ defined for '$name'"] } } } if {[info exists match]} { reportDebug "key '$match' in array '$arrname' matches '$name'" set name $match } return $name } # split string while ignore any separator character that is espaced proc psplit {str sep} { # use standard split if no sep character found if {[string first \\$sep $str] == -1} { set res [split $str $sep] } else { set previdx -1 set idx [string first $sep $str] while {$idx != -1} { # look ahead if found separator is escaped if {[string index $str [expr {$idx-1}]] ne "\\"} { # unescape any separator character when adding to list lappend res [charUnescaped [string range $str [expr {$previdx+1}]\ [expr {$idx-1}]] $sep] set previdx $idx } set idx [string first $sep $str [expr {$idx+1}]] } lappend res [charUnescaped [string range $str [expr {$previdx+1}] end]\ $sep] } return $res } # join list while escape any character equal to separator proc pjoin {lst sep} { # use standard join if no sep character found if {[string first $sep $lst] == -1} { set res [join $lst $sep] } else { set res {} foreach elt $lst { # preserve empty entries if {[info exists not_first]} { append res $sep } else { set not_first 1 } # escape any separator character when adding to string append res [charEscaped $elt $sep] } } return $res } # Dictionary-style string comparison # Use dictionary sort of lsort proc to compare two strings in the "string # compare" fashion (returning -1, 0 or 1). Tcl dictionary-style comparison # enables to compare software versions (ex: "1.10" is greater than "1.8") proc compareVersion {str1 str2} { if {$str1 eq $str2} { return 0 # put both strings in a list, then lsort it and get first element } elseif {[lindex [lsort -dictionary [list $str1 $str2]] 0] eq $str1} { return -1 } else { return 1 } } # Is provided string a version number: consider first element of string if # '.' character used in it. [0-9af] on this first part is considered valid # anything else could be used in latter elements proc isVersion {str} { return [string is xdigit -strict [lindex [split $str .] 0]] } # Return number of occurences of passed character in passed string proc countChar {str char} { return [expr {[string length $str] - [string length [string map [list\ $char {}] $str]]}] } # provide a lreverse proc for Tcl8.4 and earlier if {[info commands lreverse] eq {}} { proc lreverse {l} { set r [list] for {set i [expr {[llength $l] - 1}]} {$i >= 0} {incr i -1} { lappend r [lindex $l $i] } return $r } } # provide a lassign proc for Tcl8.4 and earlier if {[info commands lassign] eq {}} { proc lassign {values args} { uplevel 1 [list foreach $args [linsert $values end {}] break] lrange $values [llength $args] end } } proc isInList {lst elt} { return [expr {[lsearch -exact $lst $elt] != -1}] } proc notInList {lst elt} { return [expr {[lsearch -exact $lst $elt] == -1}] } proc appendNoDupToList {lstname args} { set ret 0 upvar $lstname lst foreach elt $args { if {![info exists lst] || [notInList $lst $elt]} { lappend lst $elt set ret 1 } } return $ret } proc replaceFromList {list1 item {item2 {}}} { while {[set xi [lsearch -exact $list1 $item]] >= 0} { set list1 [if {[string length $item2] == 0} {lreplace $list1 $xi $xi}\ {lreplace $list1 $xi $xi $item2}] } return $list1 } # returns elements from list1 not part of list2 and elements from list2 not # part of list1 proc getDiffBetweenList {list1 list2} { set res1 [list] set res2 [list] foreach elt $list1 { if {[notInList $list2 $elt]} { lappend res1 $elt } } foreach elt $list2 { if {[notInList $list1 $elt]} { lappend res2 $elt } } return [list $res1 $res2] } proc parseAccessIssue {modfile} { # retrieve and return access issue message if {[regexp {POSIX .* \{(.*)\}$} $::errorCode match errMsg]} { return "[string totitle $errMsg] on '$modfile'" } else { return "Cannot access '$modfile'" } } proc checkValidModule {modfile} { reportDebug $modfile # test file only once, cache result obtained to minimize file query return [expr {[info exists ::g_modfileValid($modfile)]\ ? $::g_modfileValid($modfile)\ : [set ::g_modfileValid($modfile) [readModuleContent $modfile 1 1 1]]}] } # get file modification time, cache it at first query, use cache afterward proc getFileMtime {fpath} { if {[info exists ::g_fileMtime($fpath)]} { return $::g_fileMtime($fpath) } else { return [set ::g_fileMtime($fpath) [file mtime $fpath]] } } # define proc that will be used as fallback to command provided by extension # library in case this library is not loaded proc __readFile {filename {firstline 0}} { set fid [open $filename r] set fdata [if {$firstline} {gets $fid} {read $fid}] close $fid return $fdata } proc readModuleContent {modfile {report_read_issue 0} {must_have_cookie 1}\ {only_check_validity 0}} { reportDebug $modfile set res {} # read file if {[catch { if {[info exists ::g_modfileContent($modfile)]} { lassign $::g_modfileContent($modfile) fh fdata } else { # only read beginning of file if just checking validity and not # asked to always fully read files set fdata [readFile $modfile [expr {$only_check_validity &&\ ![currentAlwaysReadFullFile]}]] # extract magic cookie (first word of modulefile) set fh [string trimright [lindex [split [string range $fdata 0 32]]\ 0] #] # cache full file read to minimize file operations if {!$only_check_validity || [currentAlwaysReadFullFile]} { set ::g_modfileContent($modfile) [list $fh $fdata] } } } errMsg ]} { if {$report_read_issue} { set msg [parseAccessIssue $modfile] if {$only_check_validity} { set res [list accesserr $msg] } else { reportError $msg } } } else { # check module validity if magic cookie is mandatory if {$must_have_cookie && ![string equal -length 8 $fh {#%Module}]} { set msg {Magic cookie '#%Module' missing} if {$only_check_validity} { set res [list invalid $msg] } else { reportInternalBug $msg $modfile } # check if min version requirement is met if magic cookie is mandatory } elseif {$must_have_cookie && [string length $fh] > 8 &&\ [compareVersion {4.5.2} [string range $fh 8 end]] <0} { set msg "Modulefile requires at least Modules version [string range\ $fh 8 end]" if {$only_check_validity} { set res [list invalid $msg] } else { reportInternalBug $msg $modfile } } else { if {$only_check_validity} { # set validity information as result set res [list true {}] } else { # set file content as result set res $fdata } } } return $res } # If given module maps to default or other symbolic versions, a list of # those versions is returned. This takes module/version as an argument. proc getVersAliasList {mod} { if {[info exists ::g_symbolHash($mod)]} { set tag_list $::g_symbolHash($mod) } else { set tag_list {} } reportDebug "'$mod' has tag list '$tag_list'" return $tag_list } proc doesModuleHaveTag {mod} { return [expr {[info exists ::g_symbolHash($mod)]}] } # get list of elements located in a directory passed as argument. a flag is # set after each element to know if it is considered hidden or not. a # fetch_hidden argument is there to control search of hidden elements. a # fetch_dotversion argument controls whether .version file should be looked at # in directory .proc will be used as a fallback to command provided by # extension library proc __getFilesInDirectory {dir fetch_hidden fetch_dotversion} { set dir_list [list] # try then catch any issue rather than test before trying # workaround 'glob -nocomplain' which does not return permission # error on Tcl 8.4, so we need to avoid registering issue if # raised error is about a no match if {[catch {set elt_list [glob $dir/*]} errMsg]} { if {$errMsg eq "no files matched glob pattern \"$dir/*\""} { set elt_list {} } else { # rethrow other error to catch it in caller proc error $errMsg $::errorInfo $::errorCode } } # Add each element in the current directory to the list if {[file readable $dir/.modulerc]} { lappend dir_list $dir/.modulerc 0 } if {$fetch_dotversion && [file readable $dir/.version]} { lappend dir_list $dir/.version 0 } foreach elt $elt_list { lappend dir_list $elt 0 } # search for hidden files if asked if {$fetch_hidden} { foreach elt [glob -nocomplain -types hidden -directory\ $dir -tails *] { switch -- $elt { .modulerc - .version - . - .. { } default { lappend dir_list $dir/$elt 1 } } } } return $dir_list } # Check a module name does match query at expected depth level when indepth # search is disabled. Define procedure on the fly to adapt its # code to indepth configuration option and querydepth and test mode params. proc defineDoesModMatchAtDepthProc {indepth querydepth test} { set procprops $indepth:$querydepth:$test # define proc if not done yet or if it was defined for another context if {[info procs doesModMatchAtDepth] eq {} ||\ $::g_doesModMatchAtDepth_procprops ne $procprops} { if {[info exists ::g_doesModMatchAtDepth_procprops]} { rename ::doesModMatchAtDepth {} } set ::g_doesModMatchAtDepth_procprops $procprops # define optimized procedure if {$indepth} { set atdepth {$mod} } else { set atdepth "\[join \[lrange \[split \$mod /\] 0 $querydepth\] /\]" } proc doesModMatchAtDepth {mod} "return \[modEqStatic $atdepth $test *\]" } } # Define procedure to check module version equals pattern. Adapt procedure # code whether icase and extended_default are enabled or disabled proc defineModVersCmpProc {icase extdfl} { set procname modVersCmpProc if {$icase} { append procname Icase } if {$extdfl} { append procname Extdfl } # define proc if not done yet or if it was defined for another context if {[info procs modVersCmp] eq {} || $::g_modVersCmp_proc ne $procname} { if {[info exists ::g_modVersCmp_proc]} { rename ::modVersCmp ::$::g_modVersCmp_proc } rename ::$procname ::modVersCmp set ::g_modVersCmp_proc $procname } } # alternative definitions of modVersCmp proc proc modVersCmpProc {cmpspec versspec modvers test {psuf {}}} { set ret 0 switch -- $cmpspec { in { foreach vers $versspec { append vers $psuf if {$test eq {eqstart}} { set ret [string equal -length [string length $vers/] $vers/\ $modvers/] } else { set ret [string $test $vers $modvers] } if {$ret} { break } } } ge { # as we work here on a version range: psuf suffix is ignored, checks # are always extended_default-enabled (as 1.2 includes 1.2.12 for # instance) and equal, eqstart and match tests are equivalent set ret [expr {[isVersion $modvers] && ([compareVersion $modvers\ $versspec] != -1 || [string match $versspec.* $modvers])}] } le { # 'ge' comment also applies here set ret [expr {[isVersion $modvers] && ([compareVersion $versspec\ $modvers] != -1 || [string match $versspec.* $modvers])}] } be { # 'ge' comment also applies here lassign $versspec lovers hivers set ret [expr {[isVersion $modvers] && ([compareVersion $modvers\ $lovers] != -1 || [string match $lovers.* $modvers]) &&\ ([compareVersion $hivers $modvers] != -1 || [string match\ $hivers.* $modvers])}] } } return $ret } proc modVersCmpProcIcase {cmpspec versspec modvers test {psuf {}}} { set ret 0 switch -- $cmpspec { in { foreach vers $versspec { append vers $psuf if {$test eq {eqstart}} { set ret [string equal -nocase -length [string length $vers/]\ $vers/ $modvers/] } else { set ret [string $test -nocase $vers $modvers] } if {$ret} { break } } } ge { set ret [expr {[isVersion $modvers] && ([compareVersion $modvers\ $versspec] != -1 || [string match -nocase $versspec.* $modvers])}] } le { set ret [expr {[isVersion $modvers] && ([compareVersion $versspec\ $modvers] != -1 || [string match -nocase $versspec.* $modvers])}] } be { lassign $versspec lovers hivers set ret [expr {[isVersion $modvers] && ([compareVersion $modvers\ $lovers] != -1 || [string match $lovers.* $modvers]) &&\ ([compareVersion $hivers $modvers] != -1 || [string match -nocase\ $hivers.* $modvers])}] } } return $ret } proc modVersCmpProcExtdfl {cmpspec versspec modvers test {psuf {}}} { set ret 0 switch -- $cmpspec { in { foreach vers $versspec { append vers $psuf if {$test eq {eqstart}} { set ret [string equal -length [string length $vers/] $vers/\ $modvers/] } else { set ret [string $test $vers $modvers] } if {$ret || [string match $vers.* $modvers]} { set ret 1 break } } } ge { set ret [expr {[isVersion $modvers] && ([compareVersion $modvers\ $versspec] != -1 || [string match $versspec.* $modvers])}] } le { set ret [expr {[isVersion $modvers] && ([compareVersion $versspec\ $modvers] != -1 || [string match $versspec.* $modvers])}] } be { lassign $versspec lovers hivers set ret [expr {[isVersion $modvers] && ([compareVersion $modvers\ $lovers] != -1 || [string match $lovers.* $modvers]) &&\ ([compareVersion $hivers $modvers] != -1 || [string match\ $hivers.* $modvers])}] } } return $ret } proc modVersCmpProcIcaseExtdfl {cmpspec versspec modvers test {psuf {}}} { set ret 0 switch -- $cmpspec { in { # check if one version in list matches foreach vers $versspec { append vers $psuf if {$test eq {eqstart}} { set ret [string equal -nocase -length [string length $vers/]\ $vers/ $modvers/] } else { set ret [string $test -nocase $vers $modvers] } # try the extended default match if {$ret || [string match -nocase $vers.* $modvers]} { set ret 1 break } } } ge { set ret [expr {[isVersion $modvers] && ([compareVersion $modvers\ $versspec] != -1 || [string match -nocase $versspec.* $modvers])}] } le { set ret [expr {[isVersion $modvers] && ([compareVersion $versspec\ $modvers] != -1 || [string match -nocase $versspec.* $modvers])}] } be { lassign $versspec lovers hivers set ret [expr {[isVersion $modvers] && ([compareVersion $modvers\ $lovers] != -1 || [string match $lovers.* $modvers]) &&\ ([compareVersion $hivers $modvers] != -1 || [string match -nocase\ $hivers.* $modvers])}] } } return $ret } # Setup a hardwire version of modEq procedure called modEqStatic. This # optimized procedure already knows the module pattern to compare to, whose # specification has already been resolved at procedure definition time, which # saves lot of processing time. proc defineModEqStaticProc {icase extdfl modspec} { set procprops $icase:$extdfl:$modspec # define proc if not done yet or if it was defined for another context if {[info procs modEqStatic] eq {} || $::g_modEqStatic_procprops ne\ $procprops} { if {[info exists ::g_modEqStatic_procprops]} { rename ::modEqStatic {} } else { # also define modVersCmp which is called by modEqStatic defineModVersCmpProc $icase $extdfl } set ::g_modEqStatic_procprops $procprops # define optimized procedure lassign [getModuleVersSpec $modspec] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob set nocasearg [expr {$icase ? {-nocase } : {}}] set pmodnameslen [string length $pmodname/] if {$pmod ne {} || $modspec eq {}} { set procbody " set pmod {$pmod} if {\$psuf ne {}} { append pmod \$psuf } if {\$test eq {eqstart}} { set ret \[string equal $nocasearg-length \[string length\ \$pmod/\] \$pmod/ \$mod/\] } else { if {\$test eq {matchin}} { set test match set pmod *\$pmod } set ret \[string \$test $nocasearg\$pmod \$mod\] }" if {$extdfl} { append procbody " if {!\$ret && \[string first / \$pmod\] != -1} { if {\$test eq {match}} { set pmodextdfl \$pmod.* } else { set pmodextdfl {$pmodescglob.*} } set ret \[string match $nocasearg\$pmodextdfl \$mod\] }" } } else { set procbody " set pmodname {$pmodname} set pmodnamere {$pmodnamere} if {\$test eq {matchin}} { set test match if {\$pmodnamere ne {}} { set pmodnamere .*\$pmodnamere } else { set pmodnamere {.*$pmodname} } } if {(\$pmodnamere ne {} && \$test eq {match} && \[regexp\ $nocasearg (^\$pmodnamere)/ \$mod/ rematch pmodname\]) ||\ \[string equal $nocasearg -length $pmodnameslen {$pmodname/}\ \$mod/\]} { set modvers \[string range \$mod \[string length \$pmodname/\]\ end\] set ret \[modVersCmp {$cmpspec} {$versspec} \$modvers \$test\ \$psuf\] } else { set ret 0 }" } append procbody " return \$ret" proc modEqStatic {mod {test equal} {psuf {}}} $procbody } } # Define procedure to check module name equals pattern. Adapt procedure # code whether icase and extended_default are enabled or disabled proc defineModEqProc {icase extdfl} { set procname modEqProc if {$icase} { append procname Icase } if {$extdfl} { append procname Extdfl } # define proc if not done yet or if it was defined for another context if {[info procs modEq] eq {} || $::g_modEq_proc ne $procname} { if {[info exists ::g_modEq_proc]} { rename ::modEq ::$::g_modEq_proc } rename ::$procname ::modEq set ::g_modEq_proc $procname } # also define modVersCmp which is called by modEq defineModVersCmpProc $icase $extdfl } # alternative definitions of modEq proc proc modEqProc {pattern mod {test equal} {trspec 1} {psuf {}}} { # extract specified module name from name and version spec if {$trspec} { lassign [getModuleVersSpec $pattern] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob } else { set pmod $pattern } # specified module can be translated in a simple mod name/vers or is empty if {$pmod ne {} || $pattern eq {}} { if {$psuf ne {}} { append pmod $psuf } if {$test eq {eqstart}} { set ret [string equal -length [string length $pmod/] $pmod/ $mod/] } else { # contains test if {$test eq {matchin}} { set test match set pmod *$pmod } set ret [string $test $pmod $mod] } } else { # contains test if {$test eq {matchin}} { set test match if {$pmodnamere ne {}} { set pmodnamere .*$pmodnamere } else { set pmodnamere .*$pmodname } } # for more complex specification, first check if module name matches # use a regexp test if module name contains wildcard characters if {($pmodnamere ne {} && $test eq {match} && [regexp (^$pmodnamere)/\ $mod/ rematch pmodname]) || [string equal -length [string length\ $pmodname/] $pmodname/ $mod/]} { # then compare versions set modvers [string range $mod [string length $pmodname/] end] set ret [modVersCmp $cmpspec $versspec $modvers $test $psuf] } else { set ret 0 } } return $ret } proc modEqProcIcase {pattern mod {test equal} {trspec 1} {psuf {}}} { if {$trspec} { lassign [getModuleVersSpec $pattern] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob } else { set pmod $pattern } if {$pmod ne {} || $pattern eq {}} { if {$psuf ne {}} { append pmod $psuf } if {$test eq {eqstart}} { set ret [string equal -nocase -length [string length $pmod/] $pmod/\ $mod/] } else { # contains test if {$test eq {matchin}} { set test match set pmod *$pmod } set ret [string $test -nocase $pmod $mod] } } else { # contains test if {$test eq {matchin}} { set test match if {$pmodnamere ne {}} { set pmodnamere .*$pmodnamere } else { set pmodnamere .*$pmodname } } # for more complex specification, first check if module name matches # use a regexp test if module name contains wildcard characters if {($pmodnamere ne {} && $test eq {match} && [regexp -nocase\ (^$pmodnamere)/ $mod/ rematch pmodname]) || [string equal -nocase\ -length [string length $pmodname/] $pmodname/ $mod/]} { # then compare versions set modvers [string range $mod [string length $pmodname/] end] set ret [modVersCmp $cmpspec $versspec $modvers $test $psuf] } else { set ret 0 } } return $ret } proc modEqProcExtdfl {pattern mod {test equal} {trspec 1} {psuf {}}} { if {$trspec} { lassign [getModuleVersSpec $pattern] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob } else { set pmod $pattern } if {$pmod ne {} || $pattern eq {}} { if {$psuf ne {}} { append pmod $psuf } if {$test eq {eqstart}} { set ret [string equal -length [string length $pmod/] $pmod/ $mod/] } else { # contains test if {$test eq {matchin}} { set test match set pmod *$pmod } set ret [string $test $pmod $mod] } # try the extended default match if not root module if {!$ret && [string first / $pmod] != -1} { if {$test eq {match}} { set pmodextdfl $pmod.* } else { set pmodextdfl $pmodescglob.* } set ret [string match $pmodextdfl $mod] } } else { # contains test if {$test eq {matchin}} { set test match if {$pmodnamere ne {}} { set pmodnamere .*$pmodnamere } else { set pmodnamere .*$pmodname } } # for more complex specification, first check if module name matches # use a regexp test if module name contains wildcard characters if {($pmodnamere ne {} && $test eq {match} && [regexp (^$pmodnamere)/\ $mod/ rematch pmodname]) || [string equal -length [string length\ $pmodname/] $pmodname/ $mod/]} { # then compare versions set modvers [string range $mod [string length $pmodname/] end] set ret [modVersCmp $cmpspec $versspec $modvers $test $psuf] } else { set ret 0 } } return $ret } proc modEqProcIcaseExtdfl {pattern mod {test equal} {trspec 1} {psuf {}}} { if {$trspec} { lassign [getModuleVersSpec $pattern] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob } else { set pmod $pattern } if {$pmod ne {} || $pattern eq {}} { if {$psuf ne {}} { append pmod $psuf } if {$test eq {eqstart}} { set ret [string equal -nocase -length [string length $pmod/] $pmod/\ $mod/] } else { # contains test if {$test eq {matchin}} { set test match set pmod *$pmod } set ret [string $test -nocase $pmod $mod] } # try the extended default match if not root module if {!$ret && [string first / $pmod] != -1} { if {$test eq {match}} { set pmodextdfl $pmod.* } else { set pmodextdfl $pmodescglob.* } set ret [string match -nocase $pmodextdfl $mod] } } else { # contains test if {$test eq {matchin}} { set test match if {$pmodnamere ne {}} { set pmodnamere .*$pmodnamere } else { set pmodnamere .*$pmodname } } # for more complex specification, first check if module name matches # use a regexp test if module name contains wildcard characters if {($pmodnamere ne {} && $test eq {match} && [regexp -nocase\ (^$pmodnamere)/ $mod/ rematch pmodname]) || [string equal -nocase\ -length [string length $pmodname/] $pmodname/ $mod/]} { # then compare versions set modvers [string range $mod [string length $pmodname/] end] set ret [modVersCmp $cmpspec $versspec $modvers $test $psuf] } else { set ret 0 } } return $ret } # check if an existing findModules cache entry matches current search by # evaluating search ids. if an exact match cannot be found, look at saved # searches that contains current search (superset of looked elements), extra # elements will be filtered-out by GetModules proc findModulesInMemCache {searchid} { # exact same search is cached if {[info exists ::g_foundModulesMemCache($searchid)]} { set match_searchid $searchid set mod_list $::g_foundModulesMemCache($searchid) # look for a superset search } else { set match_searchid {} set mod_list {} foreach cacheid [array names ::g_foundModulesMemCache] { # cache id acts as pattern to check if it contains current search if {[string match $cacheid $searchid]} { set match_searchid $cacheid set mod_list $::g_foundModulesMemCache($cacheid) break } } } return [list $match_searchid $mod_list] } # finds all module-related files matching mod in the module path dir proc findModules {dir mod depthlvl fetch_mtime fetch_hidden} { reportDebug "finding '$mod' in $dir (depthlvl=$depthlvl,\ fetch_mtime=$fetch_mtime, fetch_hidden=$fetch_hidden)" # generated search id (for cache search/save) by compacting given args set searchid $dir:$mod:$depthlvl:$fetch_mtime:$fetch_hidden # look at memory cache for a compatible result lassign [findModulesInMemCache $searchid] cache_searchid cache_list if {$cache_searchid ne {}} { reportDebug "use cache entry '$cache_searchid'" return $cache_list } defineModEqStaticProc [isIcase] [getConf extended_default] $mod # skip search in top dir if directly looking to a deep element, which means # findModules has already been called and top dir has already been analyzed if {[file dirname $mod] eq {.}} { # use catch protection to handle non-readable and non-existent dir if {[catch { set full_list {} foreach {fpelt hid} [getFilesInDirectory $dir $fetch_hidden 0] { set elt [file tail $fpelt] # include any .modulerc file found at the modulepath root if {$elt eq {.modulerc} || $mod eq {} || [modEqStatic $elt\ match]} { lappend full_list $fpelt } } }]} { return {} } } else { lappend full_list [file join $dir $mod] } foreach igndir [getConf ignored_dirs] { set ignored_dirs($igndir) 1 } array set mod_list {} for {set i 0} {$i < [llength $full_list]} {incr i 1} { set element [lindex $full_list $i] set tag_list {} set tail [file tail $element] set modulename [getModuleNameFromModulepath $element $dir] set parentname [file dirname $modulename] set moddepthlvl [llength [file split $modulename]] if {[file isdirectory $element]} { if {![info exists ignored_dirs($tail)]} { if {[catch { set elt_list [getFilesInDirectory $element $fetch_hidden 1] } errMsg]} { set mod_list($modulename) [list accesserr [parseAccessIssue\ $element] $element] } else { # Add each element in the current directory to the list foreach {fpelt hid} $elt_list { lappend full_list $fpelt # Flag hidden files if {$hid} { set hidden_list($fpelt) 1 } } } } } else { switch -glob -- $tail { .modulerc { set mod_list($modulename) [list modulerc] } .version { # skip .version file from different depth level than search # targets if no in depth mode is enabled if {$depthlvl == 0 || $moddepthlvl == $depthlvl} { set mod_list($modulename) [list modulerc] } } *~ - *,v - \#*\# { } default { # skip modfile in no in depth mode search if it does not relate # to targeted depth level and one valid modfile has already be # found for the dirs lying at other depth level if {$depthlvl == 0 || $moddepthlvl == $depthlvl || ![info\ exists modfile_indir($parentname)]} { lassign [checkValidModule $element] check_valid check_msg switch -- $check_valid { true { set mtime [expr {$fetch_mtime ? [getFileMtime\ $element] : {}}] set mod_list($modulename) [list modulefile $mtime\ $element] # a valid modfile has been found in directory if {!$fetch_hidden || ![info exists\ hidden_list($element)]} { set modfile_indir($parentname) 1 } } default { # register check error and relative message to get it # in case of direct access of this module element, but # no registering in parent directory structure as # element is not valid set mod_list($modulename) [list $check_valid\ $check_msg $element] } } } } } } } reportDebug "found [array names mod_list]" # cache search results reportDebug "create cache entry '$searchid'" set found_list [array get mod_list] set ::g_foundModulesMemCache($searchid) $found_list return $found_list } proc getModules {dir {mod {}} {fetch_mtime 0} {search {}} {fetch_hidden 0}\ {filter {}}} { global g_sourceAlias g_sourceVersion g_sourceVirtual g_resolvedPath global g_rcAlias g_moduleAlias g_rcVersion g_moduleVersion global g_rcVirtual g_moduleVirtual g_rcfilesSourced reportDebug "get '$mod' in $dir (fetch_mtime=$fetch_mtime, search=$search,\ fetch_hidden=$fetch_hidden, filter=$filter)" # generated search id (for cache search/save) by compacting given args set searchid $dir:$mod:$fetch_mtime:$search:$fetch_hidden:$filter # look at memory cache for a compatible result if {[info exists ::g_gotModulesMemCache($searchid)]} { reportDebug "use cache entry '$searchid'" return $::g_gotModulesMemCache($searchid) } # extract one module name from query set modqe [getOneModuleFromVersSpec $mod] # perform an in depth search or not set indepth [expr {[isInList $search noindepth] ? 0 : 1}] # set a default if none defined on directory entries set implicitdfl [getConf implicit_default] # automatically define latest and default sym for all modules set autosymbol [expr {$implicitdfl && [getConf advanced_version_spec]}] # match passed name against any part of avail module names set contains [expr {[isInList $search contains] ? 1 : 0}] set mtest [expr {$contains ? {matchin} : {match}}] set icase [isIcase] set wild [expr {[isInList $search wild] ? 1 : 0}] # will only keep default or latest elts in the end or remove plain dirs set filtering [expr {$filter eq {noplaindir}}] set keeping [expr {!$filtering && $filter ne {}}] # check search query string corresponds to directory set querydir [string trimright $modqe *] set isquerydir [expr {[string index $querydir end] eq {/}}] set querydir [string range $querydir 0 end-1] set querydepth [countChar $modqe /] # if search for global or user rc alias only, no dir lookup is performed # and aliases from g_rcAlias are returned if {[isInList $search rc_alias_only]} { set add_rc_defs 1 array set found_list {} } else { # find modules by (1) searching with first path element if mod is a deep # modulefile (elt1/etl2/vers) in order to catch all .modulerc and # .version files of module-related parent directories in case we need # to translate an alias or a version (2) retrieving all elements first # to then look at fully qualified file names containing searched string set parentlist [split $modqe /] if {$contains} { set findmod * } else { set findmod [lindex $parentlist 0] # if searched mod is an empty or flat element append wildcard character # to match anything starting with mod if {$wild && [llength $parentlist] <= 1} { append findmod * } } # add alias/version definitions from global or user rc to result set add_rc_defs [expr {[isInList $search rc_defs_included] ? 1 : 0}] if {!$fetch_hidden} { set fetch_hidden [isModuleSpecHidden $mod] reportDebug "is '$mod' requiring hidden search ($fetch_hidden)" } # if no indepth mode search, pass the depth level of the search query set depthlvl [expr {$indepth ? 0 : [llength $parentlist]}] array set found_list [findModules $dir $findmod $depthlvl $fetch_mtime\ $fetch_hidden] } # Phase #1: consolidate every kind of entries (directory, modulefile, # symbolic version, alias and virtual module) in found_list # define module name and version comparison procs defineModEqStaticProc $icase [getConf extended_default] $mod array set err_list {} array set hversmod_nosearch {} array set dflvers_nosearch {} foreach elt [lsort [array names found_list]] { switch -- [lindex $found_list($elt) 0] { modulerc { # process rc files them remove them from found_list if {![info exists g_rcfilesSourced($dir/$elt)]} { execute-modulerc $dir/$elt $elt $elt # Keep track of already sourced rc files not to run them again set g_rcfilesSourced($dir/$elt) 1 } unset found_list($elt) } modulefile { } default { # flag entries with error set err_list($elt) 1 } } } # add all versions found when parsing .version or .modulerc files in this # directory (skip versions not registered from this directory except if # global or user rc definitions should be included)) foreach vers [array names g_moduleVersion] { set versmod $g_moduleVersion($vers) if {($dir ne {} && [string first $dir/ $g_sourceVersion($vers)] == 0)\ || ($add_rc_defs && [info exists g_rcVersion($vers)])} { set found_list($vers) [list version $versmod] # look for hidden target if not searched yet and if symbolic version # matches passed $mod if {![info exists found_list($versmod)] && !$fetch_hidden &&\ [isModuleHidden $versmod]} { if {[modEqStatic $vers]} { array set found_list [findModules $dir $versmod 0\ $fetch_mtime 1] } else { # record hidden target not searched set hversmod_nosearch($versmod) 1 # record default version target has not been searched if {[file tail $vers] eq {default}} { set dflvers_nosearch($vers) $versmod } } } } } # add aliases found when parsing .version or .modulerc files in this # directory (skip aliases not registered from this directory except if # global or user rc definitions should be included) foreach alias [array names g_moduleAlias] { if {($dir ne {} && [string first $dir/ $g_sourceAlias($alias)] == 0)\ || ($add_rc_defs && [info exists g_rcAlias($alias)])} { set found_list($alias) [list alias $g_moduleAlias($alias)] } } # add virtual mods found when parsing .version or .modulerc files in this # directory (skip virtual mods not registered from this directory except if # global or user rc definitions should be included) foreach virt [array names g_moduleVirtual] { if {($dir ne {} && [string first $dir/ $g_sourceVirtual($virt)] == 0)\ || ($add_rc_defs && [info exists g_rcVirtual($virt)])} { lassign [checkValidModule $g_moduleVirtual($virt)] check_valid\ check_msg switch -- $check_valid { true { set mtime [expr {$fetch_mtime ? [getFileMtime\ $g_moduleVirtual($virt)] : {}}] # set mtime at index 1 like a modulefile entry set found_list($virt) [list virtual $mtime\ $g_moduleVirtual($virt)] } default { # register check error and relative message to get it in # case of direct access of this module element set found_list($virt) [list $check_valid $check_msg\ $g_moduleVirtual($virt)] set err_list($virt) 1 } } } } # Phase #2: filter-out dynamically hidden or expired elements # Phase #3: elaborate directory content with default element selection array set dir_list {} array set hid_list {} array set autosym_list {} # build list of elements contained in each directory foreach elt [array names found_list] { # track hidden entries if {[string index [file tail $elt] 0] eq {.}} { set hid_list($elt) 1 } # add a ref to element in its parent directory unless element has error, # is a symbolic version (whose target has been searched if default) or # search of hidden files is disabled and element is an hidden file then # recursively add parent element until reaching top directory if {![info exists err_list($elt)] && ([lindex $found_list($elt) 0] ne\ {version} || [info exists dflvers_nosearch($elt)]) && ($fetch_hidden\ || ![info exists hid_list($elt)])} { # change to default version target if this target has not been # searched to ensure definition of directory if {[info exists dflvers_nosearch($elt)]} { set elt $dflvers_nosearch($elt) } set direlt $elt while {[set pardir [file dirname $direlt]] ne {.}} { appendNoDupToList dir_list($pardir) [file tail $direlt] set direlt $pardir } } } # determine default element for each directory and record sorted elt list # unless if an alias or a virtual module has overwritten directory entry foreach elt [array names dir_list] { if {![info exists found_list($elt)]} { set dir_list($elt) [lsort -dictionary $dir_list($elt)] # get default element: explicitely defined default (whether it exists # or is in error) or implicit default if enabled if {[info exists g_resolvedPath($elt)]} { set dfl [file tail $g_resolvedPath($elt)] } elseif {$implicitdfl} { set dfl [lindex $dir_list($elt) end] } else { set dfl {} } # record directory properties set found_list($elt) [concat [list directory $dfl] $dir_list($elt)] # automatically define symbols for all modules if these names do not # exist yet if {$autosymbol} { if {![info exists found_list($elt/default)]} { set found_list($elt/default) [list version $elt/$dfl] set autosym_list($elt/default) 1 setModuleResolution $elt/default $elt/$dfl default 1 1 } if {![info exists found_list($elt/latest)]} { set lat [lindex $dir_list($elt) end] set found_list($elt/latest) [list version $elt/$lat] set autosym_list($elt/latest) 1 setModuleResolution $elt/latest $elt/$lat latest 1 1 } } } } # Phase #4: filter results to keep those matching search query # define module name and version comparison procs defineDoesModMatchAtDepthProc $indepth $querydepth $mtest defineModEqProc $icase [getConf extended_default] defineModEqStaticProc $icase [getConf extended_default] $mod array set mod_list {} array set fdir_list {} array set keep_list {} # keep element matching query, also add directory to result if query name # finishes with trailing slash; only keep hidden elements if they should be # included in the results or if they fully match query; only keep auto syms # if fully matched or version not specified in query foreach elt [array names found_list] { set elt_type [lindex $found_list($elt) 0] if {(($wild && [doesModMatchAtDepth $elt]) || (!$wild && ([modEqStatic\ $elt match /*] || [modEqStatic $elt match])) || ($isquerydir &&\ $elt_type eq {directory} && [modEq $querydir $elt match 0])) &&\ ($fetch_hidden || ![info exists hid_list($elt)] || [modEqStatic\ $elt]) && (![info exists autosym_list($elt)] || ([countChar $elt /]\ != $querydepth && !$contains) || [modEqStatic $elt]) && ![info\ exists mod_list($elt)]} { if {$elt_type eq {directory}} { # add matching directory to the result list, its entries will be # computed in a second time and directory will be dropped if it # has no entry in the end set mod_list($elt) [list directory] # add dir to the filter dir list to enable its removal in next # step if dir is empty if {![info exists fdir_list($elt)]} { set fdir_list($elt) {} } } else { set mod_list($elt) $found_list($elt) } # version may matches query but not its target, so it should be in # this case manually added to result (if it exists) if {$elt_type eq {version}} { set versmod [lindex $mod_list($elt) 1] # add target to dir struct (not version) if not already recorded set direlt . # recursively add targets to result (process directory content if # target is a directory set tgt_list [list $versmod] for {set i 0} {$i < [llength $tgt_list]} {incr i} { set tgt [lindex $tgt_list $i] if {![info exists mod_list($tgt)]} { if {[info exists found_list($tgt)]} { set mod_list($tgt) $found_list($tgt) # version target is directory: recursively add content if {[lindex $mod_list($tgt) 0] eq {directory}} { foreach tgtelt $dir_list($tgt) { lappend tgt_list $tgt/$tgtelt } # add dir to the filter dir list to enable its removal # in next step if dir is empty if {![info exists fdir_list($tgt)]} { set fdir_list($tgt) {} } } } # record target in dir struct if part of found elts or not # searched (this to avoid dir removal if no other elt in it) # but should not be in error or hidden if {([info exists found_list($tgt)] || [info exists\ hversmod_nosearch($tgt)]) && ![info exists\ err_list($tgt)] && ![info exists hid_list($tgt)]} { if {$i == 0} { set direlt $tgt } else { lappend fdir_list([file dirname $tgt]) [file tail\ $tgt] } } } } # skip adding element to directory content if in error or hidden } elseif {[info exists err_list($elt)] || [info exists\ hid_list($elt)]} { set direlt . } else { set direlt $elt } # track directory content, as directory are also reported to their # parent directory the directory structure is also tracked if {[set pardir [file dirname $direlt]] ne {.}} { lappend fdir_list($pardir) [file tail $direlt] # track top level entries that will be kept if result is filtered } elseif {$keeping && $direlt ne {.} && $elt_type ne {directory}} { set keep_list($elt) 1 } } } # determine default element for each directory and record sorted element # list unless directory entry has been overwritten by a different module # kind or unless only matching directory should be part of result foreach elt [lsort -decreasing [array names fdir_list]] { if {[lindex $found_list($elt) 0] eq {directory} && ([info exists\ mod_list($elt)] || $keeping)} { set fdir_list($elt) [lsort -dictionary $fdir_list($elt)] # get default element: explicitely defined default if included in # result or not found or implicit default if enabled if {[info exists g_resolvedPath($elt)] && ([info exists\ mod_list($g_resolvedPath($elt))] || ![info exists\ found_list($g_resolvedPath($elt))])} { set dfl [file tail $g_resolvedPath($elt)] } elseif {$implicitdfl} { set dfl [lindex $fdir_list($elt) end] } else { set dfl {} } # remove empty dirs if {[llength $fdir_list($elt)] == 0} { unset mod_list($elt) unset fdir_list($elt) # remove unset dir reference in parent directory. parent dir # will be treated after unset dir (due to decreasing sort) if it # needs to get in turn unset if {[set pardir [file dirname $elt]] ne {.}} { set fdir_list($pardir) [replaceFromList $fdir_list($pardir)\ [file tail $elt]] } } else { # record directory properties set mod_list($elt) [concat [list directory $dfl] $fdir_list($elt)] # list elements to keep for filtering step if {$keeping} { if {$filter eq {onlylatest}} { set keepelt $elt/[lindex $fdir_list($elt) end] } elseif {$dfl ne {}} { set keepelt $elt/$dfl } else { set keepelt {} } # keep directory if its element depth is deeper than query if {!$indepth && [countChar $keepelt /] > $querydepth} { set keep_list($elt) 1 # otherwise only keep existing modules (not directories) } elseif {[info exists mod_list($keepelt)] && [lindex\ $mod_list($keepelt) 0] ne {directory}} { set keep_list($keepelt) 1 } # when noplaindir filtering, only keep dirs with tags when indepth # enabled or if correponds to query depth when indepth disabled } elseif {$filtering && $filter eq {noplaindir} &&\ (($indepth && ![doesModuleHaveTag $elt]) || (!$indepth &&\ [countChar $elt /] != $querydepth))} { unset mod_list($elt) } } } } # now all matching modulefiles are settled, only keep those found at search # query depth level if 'noindepth' mode asked if {!$indepth} { # remove entries with more filename path separator than query pattern foreach elt [array names mod_list] { if {[countChar $elt /] > $querydepth} { unset mod_list($elt) } } } # if result should be filtered, only keep marked elements if {$keeping} { foreach elt [array names mod_list] { if {![info exists keep_list($elt)]} { unset mod_list($elt) } } } reportDebug "got [array names mod_list]" # cache search results reportDebug "create cache entry '$searchid'" set got_list [array get mod_list] set ::g_gotModulesMemCache($searchid) $got_list return $got_list } # format an element with its tags for display in a list proc formatListEltToDisplay {elt eltsgr eltsuffix tag_list tagsgr show_tags\ sgrdef {matchmap {}}} { set disp $elt$eltsuffix # hightlight matching substring if {$matchmap ne {}} { set dispsgr [sgr $eltsgr [string map $matchmap $elt]] } else { set dispsgr [sgr $eltsgr $elt] } if {$show_tags} { # display default tag graphically over element name if {[set defidx [lsearch -exact $tag_list default]] != -1 && $sgrdef} { set tag_list [lreplace $tag_list $defidx $defidx] set dispsgr [sgr de $dispsgr] } # format remaining tag list if {[llength $tag_list] > 0} { append disp "([join $tag_list :])" set tagssgr [sgr se (] foreach tag $tag_list { if {![info exists colonsgr]} { set colonsgr [sgr se :] } else { append tagssgr $colonsgr } append tagssgr [sgr $tagsgr $tag] } append tagssgr [sgr se )] append dispsgr $eltsuffix$tagssgr } else { append dispsgr $eltsuffix } } else { append dispsgr $eltsuffix } return [list $disp $dispsgr] } # format an element with its tags for a long/detailled display in a list proc formatListEltToLongDisplay {elt eltsgr eltsuffix tag_list tagsgr mtime\ sgrdef {matchmap {}}} { set disp $elt$eltsuffix set displen [string length $disp] # hightlight matching substring if {$matchmap ne {}} { set dispsgr [sgr $eltsgr [string map $matchmap $elt]] } else { set dispsgr [sgr $eltsgr $elt] } # display default tag graphically over element name if {[set defidx [lsearch -exact $tag_list default]] != -1 && $sgrdef} { set tag_list [lreplace $tag_list $defidx $defidx] set dispsgr [sgr de $dispsgr] } # format remaining tag list if {[llength $tag_list] > 0} { set tagslen [string length [join $tag_list :]] foreach tag $tag_list { if {![info exists colonsgr]} { set colonsgr [sgr se :] } else { append tagssgr $colonsgr } append tagssgr [sgr $tagsgr $tag] } } else { set tagssgr {} set tagslen 0 } set nbws1 [expr {40 - $displen}] set nbws2 [expr {20 - $tagslen + [expr {$nbws1 < 0 ? $nbws1 : 0}]}] return [list $disp $dispsgr$eltsuffix[string repeat { }\ $nbws1]$tagssgr[string repeat { } $nbws2]$mtime] } proc formatArrayValToJson {vallist} { return [expr {[llength $vallist] > 0 ? "\[ \"[join $vallist {", "}]\" \]"\ : {[]}}] } # format an element with its tags for a json display in a list proc formatListEltToJsonDisplay {elt args} { set disp "\"$elt\": \{ \"name\": \"$elt\"" foreach {key vtype val} $args { append disp ", \"$key\": " append disp [expr {$vtype eq {a} ? [formatArrayValToJson $val] :\ "\"$val\""}] } append disp "\}" return $disp } # Prepare a map list to translate later on a substring in its highlighted # counterpart. Translate substring into all module it specifies in case of an # advanced version specification. Each string obtained is right trimmed from # wildcard. No highlight is set for strings still containing wildcard chars # after right trim operation. No highlist map is returned at all if hightlight # rendering is disabled. proc prepareMapToHightlightSubstr {substr} { set maplist {} if {[sgr hi {}] ne {}} { foreach m [getAllModulesFromVersSpec $substr] { set m [string trimright $m {*?}] if {$m ne {} && [string first * $m] == -1 && [string first ? $m] ==\ -1} { lappend maplist $m [sgr hi $m] } } } return $maplist } # Finds all module versions for mod in the module path dir proc listModules {dir mod show_mtime filter search} { set flag_default_dir [getConf avail_report_dir_sym] ;# Report default dirs set flag_default_mf [getConf avail_report_mfile_sym] ;# Report modfile syms reportDebug "get '$mod' in $dir (show_mtime=$show_mtime, filter=$filter,\ search=$search)" # get module list # process full dir content but do not exit when err raised from a modulerc. array set mod_list [getModules $dir $mod $show_mtime $search 0 $filter] # output is JSON format set json [isReportFormat json] # prepare results for display set alias_colored [expr {[sgr al {}] ne {}}] set default_colored [expr {[sgr de {}] ne {}}] set matchmap [prepareMapToHightlightSubstr $mod] set clean_list {} foreach elt [array names mod_list] { set tag_list [getVersAliasList $elt] set dispsgr {} # ignore "version" entries as symbolic version are treated # along to their relative modulefile not independently switch -- [lindex $mod_list($elt) 0] { directory { if {$json} { set dispsgr [formatListEltToJsonDisplay $elt type s directory\ symbols a $tag_list] } elseif {$show_mtime} { # append / char after name to clearly indicate this is a dir lassign [formatListEltToLongDisplay $elt di / $tag_list sy {}\ $default_colored $matchmap] disp dispsgr } else { lassign [formatListEltToDisplay $elt di / $tag_list sy\ $flag_default_dir $default_colored $matchmap] disp dispsgr } } modulefile - virtual { if {$json} { set dispsgr [formatListEltToJsonDisplay $elt type s modulefile\ symbols a $tag_list pathname s [lindex $mod_list($elt) 2]] } elseif {$show_mtime} { # add to display file modification time in addition # to potential tags lassign [formatListEltToLongDisplay $elt {} {} $tag_list sy\ [clock format [lindex $mod_list($elt) 1] -format {%Y/%m/%d\ %H:%M:%S}] $default_colored $matchmap] disp dispsgr } else { lassign [formatListEltToDisplay $elt {} {} $tag_list sy\ $flag_default_mf $default_colored $matchmap] disp dispsgr } } alias { if {$json} { set dispsgr [formatListEltToJsonDisplay $elt type s alias\ symbols a $tag_list target s [lindex $mod_list($elt) 1]] } elseif {$show_mtime} { lassign [formatListEltToLongDisplay $elt al " -> [lindex\ $mod_list($elt) 1]" $tag_list sy {} $default_colored\ $matchmap] disp dispsgr } else { # add a '@' tag to indicate elt is an alias if not colored if {!$alias_colored} { lappend tag_list @ } lassign [formatListEltToDisplay $elt al {} $tag_list sy\ $flag_default_mf $default_colored $matchmap] disp dispsgr } } } if {$dispsgr ne {}} { if {$json} { lappend clean_list $dispsgr } else { lappend clean_list $disp set sgrmap($disp) $dispsgr } } } set len_list {} set max_len 0 if {$json} { upvar 0 clean_list display_list if {![info exists display_list]} { set display_list {} } } else { set display_list {} # always dictionary-sort results foreach disp [lsort -dictionary $clean_list] { # compute display element length list on sorted result lappend display_list $sgrmap($disp) lappend len_list [set len [string length $disp]] if {$len > $max_len} { set max_len $len } } } reportDebug "Returning $display_list" return [list $display_list $len_list $max_len] } proc showModulePath {} { set modpathlist [getModulePathList] if {[llength $modpathlist] > 0} { report {Search path for module files (in search order):} foreach path $modpathlist { report " [sgr mp $path]" } } else { reportWarning {No directories on module search path} } } proc displayTableHeader {sgrkey args} { foreach {title col_len} $args { set col "- [sgr $sgrkey $title] " append col [string repeat - [expr {$col_len - [string length $title] -\ 3}]] lappend col_list $col } report [join $col_list .] } proc displaySeparatorLine {{title {}} {sgrkey {}}} { set tty_cols [getTtyColumns] if {$title eq {}} { # adapt length if screen width is very small set max_rep 67 set rep [expr {$tty_cols > $max_rep ? $max_rep : $tty_cols}] report [string repeat - $rep] } else { set len [string length $title] # max expr function is not supported in Tcl8.4 and earlier if {[set lrep [expr {($tty_cols - $len - 2)/2}]] < 1} { set lrep 1 } if {[set rrep [expr {$tty_cols - $len - 2 - $lrep}]] < 1} { set rrep 1 } report "[string repeat - $lrep] [sgr $sgrkey $title] [string repeat -\ $rrep]" } } # get a list of elements and print them in a column or in a # one-per-line fashion proc displayElementList {header sgrkey hstyle one_per_line display_idx\ display_list {len_list {}} {max_len 0}} { set elt_cnt [llength $display_list] reportDebug "header=$header, sgrkey=$sgrkey, hstyle=$hstyle,\ elt_cnt=$elt_cnt, max_len=$max_len, one_per_line=$one_per_line,\ display_idx=$display_idx" # end proc if no element are to print if {$elt_cnt == 0} { return } # output is JSON format set json [isReportFormat json] # display header if any provided if {$header ne {noheader}} { if {$json} { report "\"$header\": \{" } elseif {$hstyle eq {sepline}} { displaySeparatorLine $header $sgrkey } else { report [sgr $sgrkey $header]: } } if {$json} { set displist [join $display_list ,\n] # display one element per line } elseif {$one_per_line} { if {$display_idx} { set idx 1 foreach elt $display_list { append displist [format {%2d) %s } $idx $elt] \n incr idx } } else { append displist [join $display_list \n] \n } # elsewhere display elements in columns } else { if {$display_idx} { # save room for numbers and spacing: 2 digits + ) + space set elt_prefix_len 4 } else { set elt_prefix_len 0 } # save room for two spaces after element set elt_suffix_len 2 # compute rows*cols grid size with optimized column number # the size of each column is computed to display as much column # as possible on each line incr max_len $elt_suffix_len foreach len $len_list { lappend elt_len [incr len $elt_suffix_len] } set tty_cols [getTtyColumns] # find valid grid by starting with non-optimized solution where each # column length is equal to the length of the biggest element to display set cur_cols [expr {int(($tty_cols - $elt_prefix_len) / $max_len)}] # when display is found too short to display even one column if {$cur_cols == 0} { set cols 1 set rows $elt_cnt array set col_width [list 0 $max_len] } else { set cols 0 set rows 0 } set last_round 0 set restart_loop 0 while {$cur_cols > $cols} { if {!$restart_loop} { if {$last_round} { incr cur_rows } else { set cur_rows [expr {int(ceil(double($elt_cnt) / $cur_cols))}] } for {set i 0} {$i < $cur_cols} {incr i} { set cur_col_width($i) 0 } for {set i 0} {$i < $cur_rows} {incr i} { set row_width($i) 0 } set istart 0 } else { set istart [expr {$col * $cur_rows}] # only remove width of elements from current col for {set row 0} {$row < ($i % $cur_rows)} {incr row} { incr row_width($row) -[expr {$pre_col_width + $elt_prefix_len}] } } set restart_loop 0 for {set i $istart} {$i < $elt_cnt} {incr i} { set col [expr {int($i / $cur_rows)}] set row [expr {$i % $cur_rows}] # restart loop if a column width change if {[lindex $elt_len $i] > $cur_col_width($col)} { set pre_col_width $cur_col_width($col) set cur_col_width($col) [lindex $elt_len $i] set restart_loop 1 break } # end search of maximum number of columns if computed row width # is larger than terminal width if {[incr row_width($row) +[expr {$cur_col_width($col) \ + $elt_prefix_len}]] > $tty_cols} { # start last optimization pass by increasing row number until # reaching number used for previous column number, by doing so # this number of column may pass in terminal width, if not # fallback to previous number of column if {$last_round && $cur_rows == $rows} { incr cur_cols -1 } else { set last_round 1 } break } } # went through all elements without reaching terminal width limit so # this number of column solution is valid, try next with a greater # column number if {$i == $elt_cnt} { set cols $cur_cols set rows $cur_rows array set col_width [array get cur_col_width] # number of column is fixed if last optimization round has started # reach end also if there is only one row of results if {!$last_round && $rows > 1} { incr cur_cols } } } reportDebug list=$display_list reportDebug "rows/cols=$rows/$cols,\ lastcol_item_cnt=[expr {int($elt_cnt % $rows)}]" for {set row 0} {$row < $rows} {incr row} { for {set col 0} {$col < $cols} {incr col} { set index [expr {$col * $rows + $row}] if {$index < $elt_cnt} { if {$display_idx} { append displist [format "%2d) " [expr {$index +1}]] } # cannot use 'format' as strings may contain SGR codes append displist [lindex $display_list $index][string repeat\ { } [expr {$col_width($col) - [lindex $len_list $index]}]] } } append displist \n } } if {$json && $header ne {noheader}} { append displist "\n\}" } report $displist 1 reportSeparateNextContent } # Return conf value and from where an eventual def value has been overridden proc displayConfig {val env_var {asked 0} {trans {}} {locked 0}} { array set transarr $trans # get overridden value and know what has overridden it if {$asked} { set defby " (cmd-line)" } elseif {$env_var ne {} && !$locked && [info exists ::env($env_var)]} { set defby " (env-var)" } elseif {$locked} { set defby " (locked)" } else { set defby {} } # translate fetched value if translation table exists if {[info exists transarr($val)]} { set val $transarr($val) } return $val$defby } # build list of what to undo then do to move from an initial list to a target # list, eventually checking element presence in extra from/to lists proc getMovementBetweenList {from to {extfrom {}} {extto {}}} { reportDebug "from($from) to($to) with extfrom($extfrom) extto($extto)" set undo {} set do {} # determine what element to undo then do # to restore a target list from a current list # with preservation of the element order set imax [if {[llength $to] > [llength $from]} {llength $to} {llength\ $from}] set list_equal 1 for {set i 0} {$i < $imax} {incr i} { set to_obj [lindex $to $i] set from_obj [lindex $from $i] # check from/to element presence in extra from/to list set in_extfrom [isInList $extfrom $from_obj] set in_extto [isInList $extto $to_obj] # are elts the sames and are both part of or missing from extra lists if {$to_obj ne $from_obj || $in_extfrom != $in_extto} { set list_equal 0 } if {$list_equal == 0} { if {$to_obj ne {}} { lappend do $to_obj } if {$from_obj ne {}} { lappend undo $from_obj } } } return [list $undo $do] } # build list of currently loaded modules where modulename is registered minus # module version if loaded version is the default one. a helper list may be # provided and looked at prior to module search proc getSimplifiedLoadedModuleList {{helper_raw_list {}}\ {helper_list {}}} { reportDebug called. set curr_mod_list {} set curr_nuasked_list {} set modpathlist [getModulePathList] foreach mod [getLoadedModuleList] { # if mod found in a previous LOADEDMODULES list use simplified # version of this module found in relative helper list (previously # computed simplified list) if {[set helper_idx [lsearch -exact $helper_raw_list $mod]] != -1} { set simplemod [lindex $helper_list $helper_idx] # look through modpaths for a simplified mod name if not full path } elseif {![isModuleFullPath $mod] && [llength $modpathlist] > 0} { set modfile [getModulefileFromLoadedModule $mod] set parentmod [file dirname $mod] set simplemod $mod # simplify to parent name as long as it resolves to current mod while {$parentmod ne {.}} { lassign [getPathToModule $parentmod $modpathlist 0] parentfile if {$parentfile eq $modfile} { set simplemod $parentmod set parentmod [file dirname $parentmod] } else { set parentmod . } } } else { set simplemod $mod } lappend curr_mod_list $simplemod # record not user asked module list in simplified version form if {![isModuleUserAsked $mod]} { lappend curr_nuasked_list $simplemod } } return [list $curr_mod_list $curr_nuasked_list] } # return saved collections found in user directory which corresponds to # enabled collection target if any set. proc findCollections {} { if {[info exists ::env(HOME)]} { set coll_search $::env(HOME)/.module/* } else { reportErrorAndExit {HOME not defined} } # find saved collections (matching target suffix) # a target is a domain on which a collection is only valid. # when a target is set, only the collections made for that target # will be available to list and restore, and saving will register # the target footprint set colltarget [getConf collection_target] if {$colltarget ne {}} { append coll_search .$colltarget } # workaround 'glob -nocomplain' which does not return permission # error on Tcl 8.4, so we need to avoid raising error if no match # glob excludes by default files starting with "." if {[catch {set coll_list [glob $coll_search]} errMsg ]} { if {$errMsg eq "no files matched glob pattern \"$coll_search\""} { set coll_list {} } else { reportErrorAndExit "Cannot access collection directory.\n$errMsg" } } return $coll_list } # get filename corresponding to collection name provided as argument. # name provided may already be a file name. collection description name # (with target info if any) is returned along with collection filename proc getCollectionFilename {coll} { # initialize description with collection name set colldesc $coll if {$coll eq {}} { reportErrorAndExit {Invalid empty collection name} # is collection a filepath } elseif {[string first / $coll] > -1} { # collection target has no influence when # collection is specified as a filepath set collfile $coll # elsewhere collection is a name } elseif {[info exists ::env(HOME)]} { set collfile $::env(HOME)/.module/$coll # if a target is set, append the suffix corresponding # to this target to the collection file name set colltarget [getConf collection_target] if {$colltarget ne {}} { append collfile .$colltarget # add knowledge of collection target on description append colldesc " (for target \"$colltarget\")" } } else { reportErrorAndExit {HOME not defined} } return [list $collfile $colldesc] } # generate collection content based on provided path and module lists proc formatCollectionContent {path_list mod_list nuasked_list {sgr 0}} { set content {} # graphically enhance module command if asked set modcmd [expr {$sgr ? [sgr cm module] : {module}}] # start collection content with modulepaths foreach path $path_list { # enclose path if space character found in it if {[string first { } $path] != -1} { set path "{$path}" } # 'module use' prepends paths by default so we clarify # path order here with --append flag append content "$modcmd use --append $path" \n } # then add modules foreach mod $mod_list { # mark modules not asked by user to restore the user asked state set opt [expr {[isInList $nuasked_list $mod] ? {--notuasked } : {}}] # enclose module if space character found in it if {[string first { } $mod] != -1} { set mod "{$mod}" } append content "$modcmd load $opt$mod" \n } return $content } # read given collection file and return the path and module lists it defines proc readCollectionContent {collfile colldesc} { # init lists (maybe coll does not set mod to load) set path_list {} set mod_list {} set nuasked_list {} # read file if {[catch { set fdata [split [readFile $collfile] \n] } errMsg ]} { reportErrorAndExit "Collection $colldesc cannot be read.\n$errMsg" } # analyze collection content foreach fline $fdata { if {[regexp {module use (.*)$} $fline match patharg] == 1} { # paths are appended by default set stuff_path append # manage multiple paths and path options specified on single line, # for instance "module use --append path1 path2 path3", with list # representation of patharg (which handles quoted elements containing # space in their name) foreach path $patharg { # following path is asked to be appended if {($path eq {--append}) || ($path eq {-a})\ || ($path eq {-append})} { set stuff_path append # following path is asked to be prepended # collection generated with 'save' does not prepend } elseif {($path eq {--prepend}) || ($path eq {-p})\ || ($path eq {-prepend})} { set stuff_path prepend } else { # ensure given path is absolute to be able to correctly # compare with paths registered in MODULEPATH set path [getAbsolutePath $path] # add path to end of list if {$stuff_path eq {append}} { lappend path_list $path # insert path to first position } else { set path_list [linsert $path_list 0 $path] } } } } elseif {[regexp {module load (.*)$} $fline match modarg] == 1} { # manage multiple modules specified on a single line, for instance # "module load mod1 mod2 mod3", with list representation of modarg # make a list of modules that were not directly asked by user set cleanlist [lsearch -all -inline -not -exact $modarg\ --notuasked] if {[llength $modarg] != [llength $cleanlist]} { set nuasked_list [concat $nuasked_list $cleanlist] } set mod_list [concat $mod_list $cleanlist] } } return [list $path_list $mod_list $nuasked_list] } # analyze/translate command name passed to module proc parseModuleCommandName {command defaultcmd} { set cmdempty 0 # resolve command if alias or shortcut name used switch -- $command { add {set command load} rm - remove {set command unload} show {set command display} apropos - keyword {set command search} {} { # if empty string supplied translate to default command set command $defaultcmd set cmdempty 1 } default { # specific match for shortcut names set cmdlen [string length $command] foreach {match minlen sccmd} {load 2 load unload 4 unload delete 3\ unload refresh 3 reload reload 3 reload switch 2 switch swap 2\ switch display 2 display available 2 avail aliases 2 aliases list\ 2 list whatis 2 whatis purge 2 purge initadd 5 initadd initload 6\ initadd initprepend 5 initprepend initswitch 6 initswitch\ initswap 6 initswitch initunload 8 initrm initlist 5 initlist} { if {$cmdlen >= $minlen && [string equal -length $cmdlen $command\ $match]} { set command $sccmd break } } } } set cmdvalid [isInList [list load unload reload use unuse source switch\ display avail aliases path paths list whatis search purge save restore\ saverm saveshow savelist initadd initprepend initswitch initrm initlist\ initclear autoinit clear config help test prepend-path append-path\ remove-path is-loaded is-saved is-used is-avail info-loaded] $command] return [list $command $cmdvalid $cmdempty] } # analyze arg list passed to a module cmd to set options proc parseModuleCommandArgs {cmd args} { set show_oneperline 0 set show_mtime 0 set show_filter {} set search_filter [expr {[getConf avail_indepth] ? {} : {noindepth}}] set search_match [getConf search_match] set dump_state 0 set otherargs {} # parse argument list foreach arg $args { switch -glob -- $arg { -j - --json { # enable json output only on supported command if {[isInList [list avail savelist list search whatis] $cmd]} { set ::g_report_format json set show_oneperline 0 set show_mtime 0 } } -t - --terse { set show_oneperline 1 set show_mtime 0 set ::g_report_format plain } -l - --long { set show_mtime 1 set show_oneperline 0 set ::g_report_format plain } -d - --default { # in case of *-path command, -d means --delim if {$arg eq {-d} && [string match *-path $cmd]} { lappend otherargs $arg } else { set show_filter onlydefaults } } -L - --latest { set show_filter onlylatest } -C - --contains { set search_match contains } -S - --starts-with { set search_match starts_with } --indepth { # empty value means 'in depth' as it is default behavior set search_filter {} } --no-indepth { set search_filter noindepth } --dump-state { set dump_state 1 } --auto - --no-auto - -f - --force { reportWarning "Unsupported option '$arg'" } default { lappend otherargs $arg } } } reportDebug "(show_oneperline=$show_oneperline, show_mtime=$show_mtime,\ show_filter=$show_filter, search_filter=$search_filter,\ search_match=$search_match, dump_state=$dump_state, otherargs=$otherargs)" return [list $show_oneperline $show_mtime $show_filter $search_filter\ $search_match $dump_state $otherargs] } # when advanced_version_spec option is enabled, parse argument list to set in # a global context version specification of modules passed as argument. # specification may vary whether it comes from the ml or another command. proc parseModuleVersionSpecifier {mlspec args} { # skip arg parse if proc was already call with same arg set by an upper # proc. check all args to ensure current arglist does not deviate from # what was previously parsed foreach arg $args { if {![info exists ::g_moduleVersSpec($arg)]} { set need_parse 1 break } } if {[info exists need_parse]} { if {[getConf advanced_version_spec]} { set invalidversspec 0 set invalidversrange 0 set mlunload 0 set arglist [list] set unarglist [list] foreach arg $args { # extract module name and version specifier from arg set curverslist [lassign [split $arg @] curmod] # preserve empty argument if {$curmod ne {} || $arg eq {}} { # save previous module version spec and transformed arg if any if {[info exists modarglist]} { set modarg [join $modarglist] if {[info exists modname] && ($modname ne {} || $modspec eq {})} { setModuleVersSpec $modarg $modname $cmpspec $versspec # rework args to have 1 str element for whole module spec # append to unload list if ml spec and - prefix used if {$mlunload} { lappend unarglist $modarg } else { lappend arglist $modarg } } elseif {$modspec ne {}} { knerror "No module name defined in argument '$modarg'" } unset modarglist } if {$mlspec} { if {[string index $curmod 0] eq {-}} { set arg [string range $arg 1 end] set curmod [string range $curmod 1 end] set mlunload 1 } else { set mlunload 0 } } set modname $curmod set modspec {} } set modspec [lindex $curverslist end] set versspecislist [expr {[string first , $modspec] != -1}] set versspecisrange [expr {[string first : $modspec] != -1}] # no deep version specification allowed nor list/range mix if {[string first / $modspec] != -1 || ($versspecislist &&\ $versspecisrange)} { set invalidversspec 1 # ',' separates multiple versions } elseif {$versspecislist} { set cmpspec in set versspec [split $modspec ,] # empty element in list is erroneous set invalidversspec [expr {[lsearch -exact $versspec {}] != -1}] # ':' separates range elements } elseif {$versspecisrange} { set versspec [split $modspec :] set lovers [lindex $versspec 0] set hivers [lindex $versspec 1] if {[llength $versspec] != 2 || ($lovers eq {} && $hivers eq\ {})} { set invalidversspec 1 } elseif {($lovers ne {} && ![isVersion $lovers]) || ($hivers\ ne {} && ![isVersion $hivers])} { set invalidversrange 1 # greater or equal } elseif {$hivers eq {}} { set cmpspec ge set versspec $lovers # lower or equal } elseif {$lovers eq {}} { set cmpspec le set versspec $hivers # between or equal } elseif {[compareVersion $lovers $hivers] == 1} { set invalidversrange 1 } else { set cmpspec be } } else { set cmpspec eq set versspec $modspec } if {$invalidversspec} { knerror "Invalid version specifier '$modspec'" } if {$invalidversrange} { knerror "Invalid version range '$modspec'" } # keep arg enclosed if composed of several words if {[string first { } $arg] != -1} { lappend modarglist "{$arg}" } else { lappend modarglist $arg } } # transform last args if {[info exists modarglist]} { set modarg [join $modarglist] if {[info exists modname] && ($modname ne {} || $modspec eq {})} { setModuleVersSpec $modarg $modname $cmpspec $versspec # rework args to have 1 string element for whole module spec # append to unload list if ml spec and - prefix used if {$mlunload} { lappend unarglist $modarg } else { lappend arglist $modarg } } elseif {$modspec ne {}} { knerror "No module name defined in argument '$modarg'" } } } else { set unarglist [list] set arglist [list] foreach arg $args { if {$mlspec && [string index $arg 0] eq {-}} { set modname [string range $arg 1 end] set mlunload 1 } else { set modname $arg set mlunload 0 } # keep arg enclosed if composed of several words if {[string first { } $modname] != -1} { set modarg "{$modname}" } else { set modarg $modname } # record spec, especially needed if arg is enclosed setModuleVersSpec $modarg $modname eq {} # append to unload list if ml spec and - prefix used if {$mlunload} { lappend unarglist $modarg } else { lappend arglist $modarg } } } } else { set arglist $args } if {$mlspec} { return [list $unarglist $arglist] } else { return $arglist } } proc setModuleVersSpec {modarg modname cmpspec versspec} { if {$versspec eq {}} { set mod $modname set modname [file dirname $modname] } else { set modname [string trimright $modname /] if {$cmpspec ne {eq}} { set mod {} } else { set mod $modname/$versspec } } # save a regexp-ready version of modname (apply # non-greedy quantifier to '*', to avoid matching final # '/' in string comparison set modnamere [string map {. \\. + \\+ * .*? ? .} $modname] if {$modname eq $modnamere} { set modnamere {} } # save a glob-special-chars escaped version of mod set modescglob [string map {* \\* ? \\?} $mod] reportDebug "Set module '$mod' (escglob '$modescglob'), module name\ '$modname' (re '$modnamere'), version cmp '$cmpspec' and version(s)\ '$versspec' for argument '$modarg'" set ::g_moduleVersSpec($modarg) [list $mod $modname $cmpspec $versspec\ $modnamere $modescglob] } proc getModuleVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { return $::g_moduleVersSpec($modarg) } else { return [list $modarg [file dirname $modarg] {} {} {} [string map {* \\*\ ? \\?} $modarg]] } } # get module name from module name and version spec if parsed proc getModuleNameFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { lassign $::g_moduleVersSpec($modarg) mod modname } else { set modname [file dirname $modarg] } return $modname } # translate module name version spec to return all modules mentionned proc getAllModulesFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { lassign $::g_moduleVersSpec($modarg) mod modname cmpspec versspec if {$mod eq {} && $cmpspec ne {eq}} { foreach vers $versspec { lappend modlist $modname/$vers } } else { # add empty mod specification if cmpspec is 'eq' lappend modlist $mod } } else { lappend modlist $modarg } return $modlist } # translate module name version spec to return one module mentionned proc getOneModuleFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { lassign $::g_moduleVersSpec($modarg) mod modname cmpspec versspec if {$mod eq {} && $cmpspec ne {eq}} { set mod $modname/[lindex $versspec 0] } } else { set mod $modarg } return $mod } # unload phase of a list of modules reload process proc reloadModuleListUnloadPhase {lmname {force 0} {errmsgtpl {}} {context\ unload}} { upvar $lmname lmlist # unload one by one to ensure same behavior whatever auto_handling state foreach mod [lreverse $lmlist] { # save user asked state before it vanishes set isuasked($mod) [isModuleUserAsked $mod] # force unload even if requiring mods are not part of the unload list # (violation state) as modules are loaded again just after if {[cmdModuleUnload $context match 0 1 0 0 $mod]} { # avoid failing module on load phase set lmlist [replaceFromList $lmlist $mod] set errMsg [string map [list _MOD_ $mod] $errmsgtpl] if {$force} { # errMsg will always be set as force mode could not be enabled # for reload sub-cmd which provides an empty msg template reportWarning $errMsg 1 # stop if one unload fails unless force mode enabled } else { knerror $errMsg } } } return [array get isuasked] } # load phase of a list of modules reload process proc reloadModuleListLoadPhase {lmname isuaskedlist {force 0} {errmsgtpl {}}\ {context load}} { upvar $lmname lmlist array set isuasked $isuaskedlist # loads are made with auto handling mode disabled to avoid disturbances # from a missing prereq automatically reloaded, so these module loads may # fail as prereq may not be satisfied anymore setConf auto_handling 0 foreach mod $lmlist { # reload module with user asked property preserved if {[cmdModuleLoad $context $isuasked($mod) $mod]} { set errMsg [string map [list _MOD_ $mod] $errmsgtpl] if {$force} { # errMsg will always be set as force mode could not be enabled # for reload sub-cmd which provides an empty msg template reportWarning $errMsg 1 # stop if one load fails unless force mode enabled } else { knerror $errMsg } } } setConf auto_handling 1 } ######################################################################## # command line commands # proc cmdModuleList {show_oneperline show_mtime} { set loadedmodlist [getLoadedModuleList] set json [isReportFormat json] if {[llength $loadedmodlist] == 0} { if {!$json} { report {No Modulefiles Currently Loaded.} } } else { set display_list {} set default_colored [expr {[sgr de {}] ne {}}] set len_list {} set max_len 0 foreach mod $loadedmodlist { if {$show_oneperline} { lappend display_list $mod } else { set modfile [getModulefileFromLoadedModule $mod] # skip rc find and execution if mod is registered as full path if {[isModuleFullPath $mod]} { set mtime [getFileMtime $mod] set tag_list {} # or if loaded module is a virtual module } elseif {[isModuleVirtual $mod $modfile]} { set mtime [getFileMtime $modfile] set tag_list {} } else { # call getModules to find and execute rc files for this mod set dir [getModulepathFromModuleName $modfile $mod] array set mod_list [getModules $dir $mod $show_mtime] # fetch info only if mod found if {[info exists mod_list($mod)]} { set mtime [lindex $mod_list($mod) 1] set tag_list [getVersAliasList $mod] } else { set tag_list {} } } if {$json} { set dispsgr [formatListEltToJsonDisplay $mod type s modulefile\ symbols a $tag_list pathname s $modfile] } elseif {$show_mtime} { if {[info exists mtime]} { set clock_mtime [clock format $mtime -format\ {%Y/%m/%d %H:%M:%S}] unset mtime } else { set clock_mtime {} } # add to display file modification time in addition to tags lassign [formatListEltToLongDisplay $mod {} {} $tag_list sy\ $clock_mtime $default_colored] disp dispsgr } else { lassign [formatListEltToDisplay $mod {} {} $tag_list sy 1\ $default_colored] disp dispsgr lappend len_list [set len [string length $disp]] if {$len > $max_len} { set max_len $len } } lappend display_list $dispsgr } } if {!$json} { if {$show_mtime} { displayTableHeader hi Package 39 Versions 19 {Last mod.} 19 } report {Currently Loaded Modulefiles:} } if {$show_mtime || $show_oneperline} { set display_idx 0 set one_per_line 1 } else { set display_idx 1 set one_per_line 0 } displayElementList noheader {} {} $one_per_line $display_idx\ $display_list $len_list $max_len } } proc cmdModuleDisplay {args} { reportDebug "displaying $args" pushMode display set first_report 1 foreach mod $args { lassign [getPathToModule $mod] modfile modname if {$modfile ne {}} { # only one separator lines between 2 modules if {$first_report} { displaySeparatorLine set first_report 0 } report [sgr hi $modfile]:\n execute-modulefile $modfile $modname $mod displaySeparatorLine } } popMode } proc cmdModulePaths {mod} { reportDebug ($mod) set dir_list [getModulePathList exiterronundef] foreach dir $dir_list { array unset mod_list array set mod_list [getModules $dir $mod 0 [list rc_defs_included]] # prepare list of dirs for alias/symbol target search, will first search # in currently looked dir, then in other dirs following precedence order set target_dir_list [concat [list $dir] [replaceFromList $dir_list\ $dir]] # forcibly enable implicit_default to resolve alias target when it # points to a directory setConf implicit_default 1 # build list of modulefile to print foreach elt [array names mod_list] { switch -- [lindex $mod_list($elt) 0] { modulefile { lappend ::g_return_text $dir/$elt } virtual { lappend ::g_return_text [lindex $mod_list($elt) 2] } alias - version { # resolve alias target set aliastarget [lindex $mod_list($elt) 1] lassign [getPathToModule $aliastarget $target_dir_list 0]\ modfile modname # add module target as result instead of alias if {$modfile ne {} && ![info exists mod_list($modname)]} { lappend ::g_return_text $modfile } } } } # reset implicit_default to restore behavior defined unsetConf implicit_default } # sort results if any and remove duplicates if {[info exists ::g_return_text]} { set ::g_return_text [lsort -dictionary -unique $::g_return_text] } else { # set empty value to return empty if no result set ::g_return_text {} } } proc cmdModulePath {mod} { reportDebug ($mod) lassign [getPathToModule $mod] modfile modname # if no result set empty value to return empty if {$modfile eq {}} { set ::g_return_text {} } else { lappend ::g_return_text $modfile } } proc cmdModuleWhatIs {{mod {}}} { cmdModuleSearch $mod {} } proc cmdModuleApropos {{search {}}} { cmdModuleSearch {} $search } proc cmdModuleSearch {{mod {}} {search {}}} { reportDebug "($mod, $search)" # disable error reporting to avoid modulefile errors # to mix with valid search results inhibitErrorReport set json [isReportFormat json] defineModEqProc [isIcase] [getConf extended_default] lappend searchmod rc_defs_included if {$mod eq {}} { lappend searchmod wild } set foundmod 0 pushMode whatis set dir_list [getModulePathList exiterronundef] foreach dir $dir_list { array unset mod_list array set mod_list [getModules $dir $mod 0 $searchmod] array unset interp_list array set interp_list {} # forcibly enable implicit_default to resolve alias target when it # points to a directory setConf implicit_default 1 # build list of modulefile to interpret foreach elt [array names mod_list] { switch -- [lindex $mod_list($elt) 0] { modulefile { set interp_list($elt) $dir/$elt # register module name in a global list (shared across # modulepaths) to get hints when solving aliases/version set full_list($elt) 1 } virtual { set interp_list($elt) [lindex $mod_list($elt) 2] set full_list($elt) 1 } alias - version { # resolve alias target set elt_target [lindex $mod_list($elt) 1] if {![info exists full_list($elt_target)]} { lassign [getPathToModule $elt_target $dir 0]\ modfile modname issuetype issuemsg # add module target as result instead of alias if {$modfile ne {} && ![info exists mod_list($modname)]} { set interp_list($modname) $modfile set full_list($modname) 1 } elseif {$modfile eq {}} { # if module target not found in current modulepath add to # list for global search after initial modulepath lookup if {[string first {Unable to locate} $issuemsg] == 0} { set extra_search($modname) [list $dir [modEq $mod\ $elt]] # register resolution error if alias name matches search } elseif {[modEq $mod $elt]} { set err_list($modname) [list $issuetype $issuemsg] } } } } invalid - accesserr { # register any error occuring on element matching search if {[modEq $mod $elt]} { set err_list($elt) $mod_list($elt) } } } } # reset implicit_default to restore behavior defined unsetConf implicit_default # in case during modulepath lookup we find an alias target we were # looking for in previous modulepath, remove this element from global # search list foreach elt [array names extra_search] { if {[info exists full_list($elt)]} { unset extra_search($elt) } } # save results from this modulepath for interpretation step as there # is an extra round of search to match missing alias target, we cannot # process modulefiles found immediately if {[array size interp_list] > 0} { set interp_save($dir) [array get interp_list] } } # forcibly enable implicit_default to resolve alias target when it points # to a directory setConf implicit_default 1 # find target of aliases in all modulepath except the one already tried foreach elt [array names extra_search] { lassign [getPathToModule $elt {} 0 no [lindex $extra_search($elt) 0]]\ modfile modname issuetype issuemsg issuefile # found target so append it to results in corresponding modulepath if {$modfile ne {}} { # get belonging modulepath dir depending of module kind if {[isModuleVirtual $modname $modfile]} { set dir [findModulepathFromModulefile\ $::g_sourceVirtual($modname)] } else { set dir [getModulepathFromModuleName $modfile $modname] } array unset interp_list if {[info exists interp_save($dir)]} { array set interp_list $interp_save($dir) } set interp_list($modname) $modfile set interp_save($dir) [array get interp_list] # register resolution error if primal alias name matches search } elseif {$modfile eq {} && [lindex $extra_search($elt) 1]} { set err_list($modname) [list $issuetype $issuemsg $issuefile] } } # reset implicit_default to restore behavior defined unsetConf implicit_default # prepare string translation to highlight search query string set matchmodmap [prepareMapToHightlightSubstr $mod] set matchsearchmap [prepareMapToHightlightSubstr $search] # interpret all modulefile we got for each modulepath foreach dir $dir_list { if {[info exists interp_save($dir)]} { array unset interp_list array set interp_list $interp_save($dir) set foundmod 1 set display_list {} # interpret every modulefiles obtained to get their whatis text foreach elt [lsort -dictionary [array names interp_list]] { set ::g_whatis {} execute-modulefile $interp_list($elt) $elt $elt # treat whatis as a multi-line text if {$search eq {} || [regexp -nocase $search $::g_whatis]} { if {$json} { lappend display_list [formatListEltToJsonDisplay $elt\ whatis a $::g_whatis] } else { set eltsgr [string map $matchmodmap $elt] foreach line $::g_whatis { set linesgr [string map $matchsearchmap $line] lappend display_list "[string repeat { } [expr {20 -\ [string length $elt]}]]$eltsgr: $linesgr" } } } } displayElementList $dir mp sepline 1 0 $display_list } } popMode reenableErrorReport # report errors if a modulefile was searched but not found if {$mod ne {} && !$foundmod} { # no error registered means nothing was found to match search if {![array exists err_list]} { set err_list($mod) [list none "Unable to locate a modulefile for\ '$mod'"] } foreach elt [array names err_list] { eval reportIssue $err_list($elt) } } } proc cmdModuleSwitch {uasked old {new {}}} { # if a single name is provided it matches for the module to load and in # this case the module to unload is searched to find the closest match # (loaded module that shares at least the same root name) if {$new eq {}} { set new $old set unload_match close } else { set unload_match match } # save orig names to register them as deps if called from modulefile set argnew $new if {$new eq $old} { set argold {} } else { set argold $old } reportDebug "old='$old' new='$new' (uasked=$uasked)" # record sumup messages from underlying unload/load actions under the same # switch message record id to report (evaluation messages still go under # their respective unload/load block pushMsgRecordId switch-$old-$new-[getEvalModuleStackDepth] set ret [cmdModuleUnload swunload $unload_match 1 0 0 0 $old] # register modulefile to unload as conflict if an unload module is # mentionned on this module switch command set in a modulefile set orig_auto_handling [getConf auto_handling] if {!$uasked && $argold ne {}} { # skip conflict declaration if old spec matches new as in this case # switch means *replace loaded version of mod by this specific version* lassign [getPathToModule $new] newmodfile newmod if {$newmod eq {} || ![modEq $argold $newmod eqstart]} { # temporarily disable auto handling just to record deps, not to try # to load or unload them (already tried) setConf auto_handling 0 catch {conflict $argold} setConf auto_handling $orig_auto_handling } } # attempt load and depre reload only if unload succeed if {!$ret} { cmdModuleLoad swload $uasked $new if {[getConf auto_handling] && [info exists deprelist] && [llength\ $deprelist] > 0} { # cmdModuleUnload handles the DepUn, UReqUn mechanisms and the unload # phase of the DepRe mechanism. List of DepRe mods and their user # asked state is set from cmdModuleUnload procedure to be used here # for the load phase of the DepRe mechanism. # Try DepRe load phase: load failure will not lead to switch failure reloadModuleListLoadPhase deprelist [array get isuasked]\ 1 {Reload of dependent _MOD_ failed} depre } # report a summary of automated evaluations if no error reportModuleEval } # report all recorded sumup messages for this evaluation reportMsgRecord "Switching from [sgr hi $old] to [sgr hi $new]" popMsgRecordId # register modulefile to load as prereq when called from modulefile if {!$uasked && !$ret && $argnew ne {}} { setConf auto_handling 0 prereq $argnew setConf auto_handling $orig_auto_handling } } proc cmdModuleSave {{coll default}} { reportDebug $coll if {![areModuleConstraintsSatisfied]} { reportErrorAndExit {Cannot save collection, some module constraints are\ not satistied} } # format collection content, version number of modulefile are saved if # version pinning is enabled if {[getConf collection_pin_version]} { set curr_mod_list [getLoadedModuleList] set curr_nuasked_list [getLoadedModuleNotUserAskedList] } else { lassign [getSimplifiedLoadedModuleList] curr_mod_list curr_nuasked_list } set save [formatCollectionContent [getModulePathList returnempty 0]\ $curr_mod_list $curr_nuasked_list] if { [string length $save] == 0} { reportErrorAndExit {Nothing to save in a collection} } # get coresponding filename and its directory lassign [getCollectionFilename $coll] collfile colldesc set colldir [file dirname $collfile] if {![file exists $colldir]} { reportDebug "Creating $colldir" file mkdir $colldir } elseif {![file isdirectory $colldir]} { reportErrorAndExit "$colldir exists but is not a directory" } reportDebug "Saving $collfile" if {[catch { set fid [open $collfile w] puts $fid $save close $fid } errMsg ]} { reportErrorAndExit "Collection $colldesc cannot be saved.\n$errMsg" } } proc cmdModuleRestore {{coll default}} { reportDebug $coll # get coresponding filename lassign [getCollectionFilename $coll] collfile colldesc if {![file exists $collfile]} { reportErrorAndExit "Collection $colldesc cannot be found" } # read collection lassign [readCollectionContent $collfile $colldesc] coll_path_list\ coll_mod_list coll_nuasked_list # collection should at least define a path or a mod if {[llength $coll_path_list] == 0 && [llength $coll_mod_list] == 0} { reportErrorAndExit "$colldesc is not a valid collection" } # forcibly enable implicit_default to restore colls saved in this mode setConf implicit_default 1 # fetch what is currently loaded set curr_path_list [getModulePathList returnempty 0] # get current loaded module list in simplified and raw versions # these lists may be used later on, see below set curr_mod_list_raw [getLoadedModuleList] set curr_nuasked_list_raw [getLoadedModuleNotUserAskedList] lassign [getSimplifiedLoadedModuleList] curr_mod_list curr_nuasked_list # determine what module to unload to restore collection # from current situation with preservation of the load order lassign [getMovementBetweenList $curr_mod_list $coll_mod_list\ $curr_nuasked_list $coll_nuasked_list] mod_to_unload mod_to_load # determine unload movement with raw loaded list in case versions are # pinning in saved collection lassign [getMovementBetweenList $curr_mod_list_raw $coll_mod_list\ $curr_nuasked_list_raw $coll_nuasked_list] mod_to_unload_raw\ mod_to_load_raw if {[llength $mod_to_unload] > [llength $mod_to_unload_raw]} { set mod_to_unload $mod_to_unload_raw } # proceed as well for modulepath lassign [getMovementBetweenList $curr_path_list $coll_path_list] \ path_to_unuse path_to_use # create an eval id to track successful/failed module evaluations pushMsgRecordId restore-$coll-[getEvalModuleStackDepth] 0 # unload modules one by one (no dependency auto unload) if {[llength $mod_to_unload] > 0} { eval cmdModuleUnload unload match 0 0 0 0 [lreverse $mod_to_unload] } # unuse paths if {[llength $path_to_unuse] > 0} { eval cmdModuleUnuse [lreverse $path_to_unuse] } # since unloading a module may unload other modules or # paths, what to load/use has to be determined after # the undo phase, so current situation is fetched again set curr_path_list [getModulePathList returnempty 0] # here we may be in a situation were no more path is left # in module path, so we cannot easily compute the simplified loaded # module list. so we provide two helper lists: simplified and raw # versions of the loaded module list computed before starting to # unload modules. these helper lists may help to learn the # simplified counterpart of a loaded module if it was already loaded # before starting to unload modules lassign [getSimplifiedLoadedModuleList $curr_mod_list_raw $curr_mod_list]\ curr_mod_list curr_nuasked_list set curr_mod_list_raw [getLoadedModuleList] set curr_nuasked_list_raw [getLoadedModuleNotUserAskedList] # determine what module to load to restore collection # from current situation with preservation of the load order lassign [getMovementBetweenList $curr_mod_list $coll_mod_list\ $curr_nuasked_list $coll_nuasked_list] mod_to_unload mod_to_load # determine load movement with raw loaded list in case versions are # pinning in saved collection lassign [getMovementBetweenList $curr_mod_list_raw $coll_mod_list\ $curr_nuasked_list_raw $coll_nuasked_list] mod_to_unload_raw\ mod_to_load_raw if {[llength $mod_to_load] > [llength $mod_to_load_raw]} { set mod_to_load $mod_to_load_raw } # proceed as well for modulepath lassign [getMovementBetweenList $curr_path_list $coll_path_list] \ path_to_unuse path_to_use # reset implicit_default to restore behavior defined unsetConf implicit_default # use paths if {[llength $path_to_use] > 0} { # always append path here to guaranty the order # computed above in the movement lists eval cmdModuleUse --append $path_to_use } # load modules one by one with user asked state preserved foreach mod $mod_to_load { cmdModuleLoad load [notInList $coll_nuasked_list $mod] $mod } popMsgRecordId 0 } proc cmdModuleSaverm {{coll default}} { reportDebug $coll # avoid to remove any kind of file with this command if {[string first / $coll] > -1} { reportErrorAndExit {Command does not remove collection specified as\ filepath} } # get coresponding filename lassign [getCollectionFilename $coll] collfile colldesc if {![file exists $collfile]} { reportErrorAndExit "Collection $colldesc cannot be found" } # attempt to delete specified colletion if {[catch { file delete $collfile } errMsg ]} { reportErrorAndExit "Collection $colldesc cannot be removed.\n$errMsg" } } proc cmdModuleSaveshow {{coll default}} { reportDebug $coll # get coresponding filename lassign [getCollectionFilename $coll] collfile colldesc if {![file exists $collfile]} { reportErrorAndExit "Collection $colldesc cannot be found" } # read collection lassign [readCollectionContent $collfile $colldesc] coll_path_list\ coll_mod_list coll_nuasked_list # collection should at least define a path or a mod if {[llength $coll_path_list] == 0 && [llength $coll_mod_list] == 0} { reportErrorAndExit "$colldesc is not a valid collection" } displaySeparatorLine report [sgr hi $collfile]:\n report [formatCollectionContent $coll_path_list $coll_mod_list\ $coll_nuasked_list 1] displaySeparatorLine } proc cmdModuleSavelist {show_oneperline show_mtime} { # if a target is set, only list collection matching this # target (means having target as suffix in their name) set colltarget [getConf collection_target] if {$colltarget ne {}} { set suffix .$colltarget set targetdesc " (for target \"$colltarget\")" } else { set suffix {} set targetdesc {} } set json [isReportFormat json] reportDebug "list collections for target \"$colltarget\"" set coll_list [findCollections] if { [llength $coll_list] == 0} { if {!$json} { report "No named collection$targetdesc." } } else { set list {} if {!$json} { if {$show_mtime} { displayTableHeader hi Collection 59 {Last mod.} 19 } report "Named collection list$targetdesc:" } set display_list {} set len_list {} set max_len 0 if {$show_mtime || $show_oneperline} { set display_idx 0 set one_per_line 1 } else { set display_idx 1 set one_per_line 0 } foreach coll [lsort -dictionary $coll_list] { # remove target suffix from names to display regsub $suffix$ [file tail $coll] {} mod if {$json} { lappend display_list [formatListEltToJsonDisplay $mod target s\ $colltarget pathname s $coll] # no need to test mod consistency as findCollections does not return # collection whose name starts with "." } elseif {$show_mtime} { set filetime [clock format [getFileMtime $coll]\ -format {%Y/%m/%d %H:%M:%S}] lappend display_list [format %-60s%19s $mod $filetime] } else { lappend display_list $mod lappend len_list [set len [string length $mod]] if {$len > $max_len} { set max_len $len } } } displayElementList noheader {} {} $one_per_line $display_idx\ $display_list $len_list $max_len } } proc cmdModuleSource {args} { reportDebug $args foreach fpath $args { set absfpath [getAbsolutePath $fpath] if {$fpath eq {}} { reportErrorAndExit {File name empty} } elseif {[file exists $absfpath]} { pushMode load # relax constraint of having a magic cookie at the start of the # modulefile to execute as sourced files may need more flexibility # as they may be managed outside of the modulefile environment like # the initialization modulerc file execute-modulefile $absfpath $absfpath $absfpath 0 popMode } else { reportErrorAndExit "File $fpath does not exist" } } } proc cmdModuleUnsource {args} { reportDebug $args foreach fpath $args { set absfpath [getAbsolutePath $fpath] if {$fpath eq {}} { reportErrorAndExit {File name empty} } elseif {[file exists $absfpath]} { pushMode unload # relax constraint of having a magic cookie at the start of the # modulefile to execute as sourced files may need more flexibility # as they may be managed outside of the modulefile environment like # the initialization modulerc file execute-modulefile $absfpath $absfpath $absfpath 0 popMode } else { reportErrorAndExit "File $fpath does not exist" } } } proc cmdModuleLoad {context uasked args} { reportDebug "loading $args (context=$context, uasked=$uasked)" set ret 0 pushMode load foreach mod $args { # if a switch action is ongoing... if {$context eq {swload}} { set swprocessing 1 # context is ReqLo if switch is called from a modulefile if {![isMsgRecordIdTop]} { set context reqlo } } # record evaluation attempt on specified module name registerModuleEvalAttempt $context $mod lassign [getPathToModule $mod] modfile modname if {$modfile eq {}} { set ret 1 # go to next module to unload continue } if {[isModuleEvalFailed load $modname]} { reportDebug "$modname ($modfile) load was already tried and failed" # nullify this evaluation attempt to avoid duplicate issue report unregisterModuleEvalAttempt $context $mod continue } # if a switch action is ongoing... if {[info exists swprocessing]} { # pass the DepRe mod list to the calling cmdModuleSwitch procedure to # let it handle the load phase of the DepRe mechanism along with the # DepRe modules set from switched off module. upvar deprelist swdeprelist upvar isuasked isuasked # transmit loaded mod name for switch report summary uplevel 1 set new $modname } # set a unique id to record messages related to this evaluation. set msgrecid load-$modname-[getEvalModuleStackDepth] pushMsgRecordId $msgrecid # record evaluation attempt on actual module name registerModuleEvalAttempt $context $modname registerModuleEvalAttempt $context $modfile # check if passed modname correspond to an already loaded modfile # and get its loaded name (in case it has been loaded as full path) set loadedmodname [getLoadedMatchingName $modname] if {$loadedmodname ne {}} { set modname $loadedmodname } pushSettings if {[set errCode [catch { if {[isModuleLoaded $modname] || [isModuleLoading $modname]} { reportDebug "$modname ($modfile) already loaded/loading" # exit treatment but no need to restore settings continue } # register altname of modname prior any conflict check eval setLoadedAltname "{$modname}" [getAllModuleResolvedName\ $modname 1] if {[getConf auto_handling]} { # get loaded modules holding a requirement on modname and able to # be reloaded set deprelist [getUnmetDependentLoadedModuleList $modname] reportDebug "depre mod list is '$deprelist'" # Reload all modules that have declared a prereq on mod as they # may take benefit from their prereq availability if it is newly # loaded. First perform unload phase of the reload, prior mod load # to ensure these dependent modules are unloaded with the same # loaded prereq as when they were loaded if {[llength $deprelist] > 0} { array set isuasked [reloadModuleListUnloadPhase deprelist\ [getForce] {Unload of dependent _MOD_ failed} depun] if {[info exists swprocessing]} { if {[info exists swdeprelist]} { set swdeprelist [concat $deprelist $swdeprelist] } else { set swdeprelist $deprelist } } } } if {[execute-modulefile $modfile $modname $mod]} { break } # register this evaluation on the main one that triggered it (after # load evaluation to report correct order with other evaluations) registerModuleEval $context $modname # raise an error if a conflict violation is detected # do that after modfile evaluation to give it the chance to solve its # (module unload) conflicts through its evaluation lassign [doesModuleConflict $modname] doescon modconlist\ moddecconlist set retisconun [eval isModuleEvaluated conun "{$modname}"\ $modconlist] if {![set retiseval [eval isModuleEvaluated any "{$modname}"\ $modconlist]] || [currentMsgRecordId] ne [topMsgRecordId] ||\ !$retisconun} { # more appropriate msg if an evaluation was attempted or is # by-passed. error is reported using declared conflict name (as if # it was raised raised from a conflict modulefile command) set conmsg [expr {$retiseval || [getForce] ? [getConIsLoadedMsg\ $moddecconlist [is-loading $modconlist]] : [getErrConflictMsg\ $modname $moddecconlist]}] } # still proceed if force mode enabled if {[getForce] && $doescon} { defineModEqProc [isIcase] [getConf extended_default] # report warning if not already done set report_con 1 if {[info exists ::report_conflict($modname)]} { # check if conflict has not been already reported with an # alternative name foreach modalt [concat [getLoadedAltname $modconlist]\ $modconlist $moddecconlist] { foreach reportmod $::report_conflict($modname) { if {[doesModuleMatchesName $modalt $reportmod]} { set report_con 0 break } } } } if {$report_con && [info exists conmsg]} { reportWarning $conmsg } # raise conun-specific msg to top level if attempted if {$retisconun} { reportWarning [getErrConUnMsg $moddecconlist] 1 } } elseif {$doescon} { if {$retisconun} { if {[info exists conmsg]} { reportError $conmsg } # raise conun-specific msg to top level if attempted knerror [getErrConUnMsg $moddecconlist] } else { set errlocalreport 1 knerror $conmsg } } add-path append LOADEDMODULES $modname # allow duplicate modfile entries for virtual modules add-path append --duplicates _LMFILES_ $modfile # update cache arrays setLoadedModule $modname $modfile $uasked # register declared conflict in environment if {[set modcon [getLoadedConflict $modname 1]] ne {}} { add-path append MODULES_LMCONFLICT $modcon } # declare the prereq of this module if {[set modpre [getLoadedPrereq $modname 1]] ne {}} { add-path append MODULES_LMPREREQ $modpre } # declare module as not asked by user (automatically loaded as # dependency) if it is the case if {!$uasked} { add-path append MODULES_LMNOTUASKED $modname } # declare the alternative names of this module if {[set modalt [getLoadedAltname $modname 1]] ne {}} { add-path append MODULES_LMALTNAME $modalt } # Load phase of dependent module reloading. These modules can adapt # now that mod is seen loaded. Except if switch action ongoing (DepRe # load phase will occur from switch) if {[getConf auto_handling] && [llength $deprelist] > 0 && ![info\ exists swprocessing]} { reloadModuleListLoadPhase deprelist [array get isuasked]\ [getForce] {Reload of dependent _MOD_ failed} depre } # report a summary of automated evaluations if no error reportModuleEval } errMsg]] != 0 && $errCode != 4} { if {$errMsg ne {}} { reportError $errMsg [expr {![info exists errlocalreport]}] } # report switched-on module load failure under switch info block # unless the above reportError call already put a mesg to this block if {[info exists swprocessing] && ($errMsg eq {} || [info exists\ errlocalreport])} { # warn as this issue does not lead to a rollback of switch action reportWarning "Load of switched-on $modname failed" 1 } # rollback settings if some evaluation went wrong set ret 1 restoreSettings # remove from successfully evaluated module list registerModuleEval $context $modname 1 load unset -nocomplain errlocalreport } popSettings # report all recorded messages for this evaluation except if module were # already loaded if {$errCode != 4} { reportMsgRecord "Loading [sgr hi $modname]" } popMsgRecordId } popMode return $ret } proc cmdModuleUnload {context match auto force onlyureq onlyndep args} { reportDebug "unloading $args (context=$context, match=$match, auto=$auto,\ force=$force, onlyureq=$onlyureq, onlyndep=$onlyndep)" set ret 0 pushMode unload foreach mod $args { # if a switch action is ongoing... if {$context eq {swunload}} { set swprocessing 1 # context is ConUn if switch is called from a modulefile if {![isMsgRecordIdTop]} { set context conun } } # record evaluation attempt on specified module name registerModuleEvalAttempt $context $mod # resolve by also looking at matching loaded module lassign [getPathToModule $mod {} 1 $match] modfile modname errkind if {$modfile eq {}} { # no error return if module is not loaded if {$errkind eq {notloaded}} { reportDebug "$modname is not loaded" } else { set ret 1 } # go to next module to unload continue } if {$onlyureq && ![isModuleUnloadable $modname]} { reportDebug "$modname ($modfile) is required by loaded module or\ asked by user" continue } if {[isModuleEvalFailed unload $modname]} { reportDebug "$modname ($modfile) unload was already tried and failed" # nullify this evaluation attempt to avoid duplicate issue report unregisterModuleEvalAttempt $context $mod continue } # if a switch action is ongoing... if {[info exists swprocessing]} { # pass the DepRe mod list to the calling cmdModuleSwitch # procedure to let it handle the load phase of the DepRe # mechanism once the switched-to module will be loaded upvar deprelist deprelist upvar isuasked isuasked # transmit unloaded mod name for switch report summary uplevel 1 set old $modname } # set a unique id to record messages related to this evaluation. set msgrecid unload-$modname-[getEvalModuleStackDepth] pushMsgRecordId $msgrecid # record evaluation attempt on actual module name registerModuleEvalAttempt $context $modname registerModuleEvalAttempt $context $modfile pushSettings if {[set errCode [catch { # error if unloading module violates a registered prereq # and auto handling mode is disabled set prereq_list [getDependentLoadedModuleList [list $modname]] if {[llength $prereq_list] > 0 && (![getConf auto_handling] ||\ !$auto)} { # force mode should not affect if we only look for mods w/o dep if {([getForce] || $force) && !$onlyndep} { # in case unload is called for a DepRe mechanism or a purge do # not warn about prereq violation enforced as it is due to the # dependent module which is already in a violation state if {$auto || !$force} { reportWarning [getDepLoadedMsg $prereq_list] } } else { set errlocalreport 1 # exit treatment but no need to set return code to error if # called from a 'module unload' command in a modulefile in a # load evaluation mode, as set conflict will raise error at end # of modulefile evaluation if {$onlyndep} { set errharmless 1 } knerror [expr {[eval isModuleEvaluated any "{$modname}"\ $prereq_list] ? [getDepLoadedMsg $prereq_list] :\ [getErrPrereqMsg $modname $prereq_list 0]}] } } if {[getConf auto_handling] && $auto} { # compute lists of modules to update due to modname unload prior # unload to get requirement info before it vanishes # DepUn: Dependent to Unload (modules actively requiring modname # or a module part of this DepUn batch) set depunnpolist [getDependentLoadedModuleList [list $modname] 1\ 0 1 0] set depunlist [getDependentLoadedModuleList [list $modname] 1 0 0 0] # look at both regular dependencies or No Particular Order # dependencies: use NPO result if situation can be healed with NPO # dependencies, which will be part of DepRe list to restore the # correct loading order for them if {[llength $depunnpolist] <= [llength $depunlist]} { set depunlist $depunnpolist } reportDebug "depun mod list is '$depunlist'" # do not check for UReqUn mods coming from DepUn modules as these # DepUn modules are reloaded if {[info exists swprocessing]} { set urequnqry [list $modname] } else { set urequnqry [concat $depunlist [list $modname]] } # UReqUn: Useless Requirement to Unload (autoloaded requirements # of modname or DepUn modules not required by any remaining mods) set urequnlist [getUnloadableLoadedModuleList $urequnqry] reportDebug "urequn mod list is '$urequnlist'" # DepRe: Dependent to Reload (modules optionnaly dependent or in # conflict with modname, DepUn or UReqUn modules + modules # dependent of a module part of this DepRe batch) set deprelist [getDependentLoadedModuleList [concat $urequnlist\ $depunlist [list $modname]] 0 0 1 0 1 1] reportDebug "depre mod list is '$deprelist'" # DepUn mods are merged into the DepRe list as an attempt to # reload these DepUn mods is made once switched-to mod loaded if {[info exists swprocessing]} { set deprelist [sortModulePerLoadedAndDepOrder [concat\ $depunlist $deprelist] 1] set depunlist {} } # Reload of all DepRe mods, as they may adapt from the mod unloads # happening here. First perform unload phase of the reload, prior # mod unloads to ensure these dependent mods are unloaded with the # same loaded prereq as when they were loaded. Avoid modules not # satisfying their constraint. if {[llength $deprelist] > 0} { array set isuasked [reloadModuleListUnloadPhase deprelist\ [getForce] {Unload of dependent _MOD_ failed} depun] } # DepUn modules unload prior main mod unload if {[llength $depunlist] > 0} { foreach unmod [lreverse $depunlist] { if {[cmdModuleUnload depun match 0 0 0 0 $unmod]} { # stop if one unload fails unless force mode enabled set errMsg "Unload of dependent $unmod failed" if {[getForce] || $force} { reportWarning $errMsg 1 } else { knerror $errMsg } } } } } # register this evaluation on the main one that triggered it (prior # unload evaluation to report correct order with other evaluations) registerModuleEval $context $modname if {[execute-modulefile $modfile $modname $mod]} { break } # get module position in loaded list to remove corresponding loaded # modulefile (entry at same position in _LMFILES_) # need the unfiltered loaded module list to get correct index set lmidx [lsearch -exact [getLoadedModuleList 0] $modname] unload-path LOADEDMODULES $modname unload-path --index _LMFILES_ $lmidx if {![isModuleUserAsked $modname]} { unload-path MODULES_LMNOTUASKED $modname } # update cache arrays unsetLoadedModule $modname $modfile # unregister declared conflict if {[set modcon [getLoadedConflict $modname 1]] ne {}} { unload-path MODULES_LMCONFLICT $modcon } unsetLoadedConflict $modname # unset prereq declared for this module if {[llength [set modpre [getLoadedPrereq $modname]]] > 0} { unload-path MODULES_LMPREREQ [getLoadedPrereq $modname 1] } unsetLoadedPrereq $modname # unset alternative names declared for this module if {[llength [set modalt [getLoadedAltname $modname]]] >0} { unload-path MODULES_LMALTNAME [getLoadedAltname $modname 1] } unsetLoadedAltname $modname if {[getConf auto_handling] && $auto} { # UReqUn modules unload now DepUn+main mods are unloaded if {[llength $urequnlist] > 0} { set urequnlist [lreverse $urequnlist] for {set i 0} {$i < [llength $urequnlist]} {incr i 1} { set unmod [lindex $urequnlist $i] if {[cmdModuleUnload urequn match 0 0 0 0 $unmod]} { # just warn if UReqUn module cannot be unloaded, main # unload process continues, just the UReqUn modules that # are required by unmod (whose unload failed) are # withdrawn from UReqUn module list reportWarning "Unload of useless requirement $unmod\ failed" 1 lassign [getDiffBetweenList $urequnlist\ [getRequiredLoadedModuleList [list $unmod]]]\ urequnlist } } } # DepRe modules load phase now DepUn+UReqUn+main mods are unloaded # except if a switch action is ongoing as this DepRe load phase # will occur after the new mod load if {[llength $deprelist] > 0 && ![info exists swprocessing]} { reloadModuleListLoadPhase deprelist [array get isuasked]\ [getForce] {Reload of dependent _MOD_ failed} depre } } # report a summary of automated evaluations if no error reportModuleEval } errMsg]] != 0 && $errCode != 4} { if {$errMsg ne {}} { reportError $errMsg [expr {![info exists errlocalreport]}] } # report switched-off module unload failure under switch info block # unless the above reportError call already put a mesg to this block if {[info exists swprocessing] && ($errMsg eq {} || [info exists\ errlocalreport])} { reportError "Unload of switched-off $modname failed" 1 } # rollback settings if some evaluation went wrong if {![info exists errharmless]} { set ret 1 restoreSettings # remove from successfully evaluated module list registerModuleEval $context $modname 1 unload } unset -nocomplain errlocalreport errharmless } popSettings # report all recorded messages for this evaluation reportMsgRecord "Unloading [sgr hi $modname]" popMsgRecordId } popMode return $ret } proc cmdModulePurge {} { reportDebug called. # create an eval id to track successful/failed module evaluations pushMsgRecordId purge-[getEvalModuleStackDepth] 0 # unload one by one to ensure same behavior whatever auto_handling state # force it to handle loaded modules in violation state eval cmdModuleUnload unload match 0 1 0 0 [lreverse [getLoadedModuleList]] popMsgRecordId 0 } proc cmdModuleReload {args} { # reload all loaded modules if no module list passed if {[llength $args] == 0} { set lmlist [getLoadedModuleList] } else { set lmlist $args } reportDebug "reloading $lmlist" # create an eval id to track successful/failed module evaluations pushMsgRecordId reload-[getEvalModuleStackDepth] 0 # no reload of all loaded modules attempt if constraints are violated if {[llength $args] == 0 && ![areModuleConstraintsSatisfied]} { reportError {Cannot reload modules, some of their constraints are not\ satistied} } else { pushSettings if {[set errCode [catch { # run unload then load-again phases array set isuasked [reloadModuleListUnloadPhase lmlist] reloadModuleListLoadPhase lmlist [array get isuasked] } errMsg]] == 1} { # rollback settings if some evaluation went wrong restoreSettings } popSettings } popMsgRecordId 0 } proc cmdModuleAliases {} { # disable error reporting to avoid modulefile errors # to mix with avail results inhibitErrorReport # parse paths to fill g_moduleAlias and g_moduleVersion foreach dir [getModulePathList exiterronundef] { getModules $dir {} 0 {} } reenableErrorReport set display_list {} foreach name [lsort -dictionary [array names ::g_moduleAlias]] { # exclude hidden aliases from result if {![isModuleHidden $name]} { lappend display_list "[sgr al $name] -> $::g_moduleAlias($name)" } } displayElementList Aliases hi sepline 1 0 $display_list set display_list {} foreach name [lsort -dictionary [array names ::g_moduleVersion]] { # exclude hidden versions or versions targeting an hidden module if {![isModuleHidden $name] && ![isModuleHidden\ $::g_moduleVersion($name)]} { lappend display_list "[sgr sy $name] -> $::g_moduleVersion($name)" } } displayElementList Versions hi sepline 1 0 $display_list } proc cmdModuleAvail {show_oneperline show_mtime show_filter search_filter\ search_match args} { if {[llength $args] == 0} { lappend args * } if {$show_mtime || $show_oneperline} { set one_per_line 1 set hstyle terse set theader_shown 0 set theader_cols [list hi Package/Alias 39 Versions 19 {Last mod.} 19] } else { set one_per_line 0 set hstyle sepline } # set a default filter (do not print dirs with no tag) if none set if {$show_filter eq {}} { set show_filter noplaindir } # disable error reporting to avoid modulefile errors # to mix with avail results inhibitErrorReport foreach mod $args { # look if aliases have been defined in the global or user-specific # modulerc and display them if any in a dedicated list lassign [listModules {} $mod $show_mtime $show_filter [concat\ $search_filter [list $search_match rc_alias_only wild]]]\ display_list len_list max_len if {[llength $display_list] > 0 && $show_mtime && !$theader_shown} { set theader_shown 1 eval displayTableHeader $theader_cols } displayElementList {global/user modulerc} hi $hstyle $one_per_line 0\ $display_list $len_list $max_len foreach dir [getModulePathList exiterronundef] { lassign [listModules $dir $mod $show_mtime $show_filter [concat\ $search_filter [list $search_match wild]]] display_list len_list\ max_len if {[llength $display_list] > 0 && $show_mtime && !$theader_shown} { set theader_shown 1 eval displayTableHeader $theader_cols } displayElementList $dir mp $hstyle $one_per_line 0 $display_list\ $len_list $max_len } } reenableErrorReport } proc cmdModuleUse {args} { reportDebug $args if {$args eq {}} { showModulePath } else { set pos prepend foreach path $args { switch -- $path { -a - --append - -append { set pos append } -p - --prepend - -prepend { set pos prepend } {} { reportError {Directory name empty} } default { # tranform given path in an absolute path to avoid dependency # to the current work directory. except if this path starts # with a variable reference if {[string index $path 0] ne {$}} { set path [getAbsolutePath $path] } if {[file isdirectory [resolvStringWithEnv $path]]} { pushMode load catch { add-path $pos MODULEPATH $path } popMode } else { reportError "Directory '$path' not found" } } } } } } proc cmdModuleUnuse {args} { reportDebug $args if {$args eq {}} { showModulePath } else { foreach path $args { # get current module path list # no absolute path conversion for the moment if {![info exists modpathlist]} { set modpathlist [getModulePathList returnempty 0 0] } # skip empty string if {$path eq {}} { reportError {Directory name empty} continue } # transform given path in an absolute path which should have been # registered in the MODULEPATH env var. however for compatibility # with previous behavior where relative paths were registered in # MODULEPATH given path is first checked against current path list set abspath [getAbsolutePath $path] if {[isInList $modpathlist $path]} { set unusepath $path } elseif {[isInList $modpathlist $abspath]} { set unusepath $abspath } else { set unusepath {} } if {$unusepath ne {}} { pushMode unload catch { unload-path MODULEPATH $unusepath } popMode # refresh path list after unload set modpathlist [getModulePathList returnempty 0 0] if {[isInList $modpathlist $unusepath]} { reportWarning "Did not unuse $unusepath" } } } } } proc cmdModuleAutoinit {} { reportDebug called. # flag to make renderSettings define the module command set ::g_autoInit 1 # initialize env variables around module command pushMode load # register command location setenv MODULES_CMD [getAbsolutePath $::argv0] # define current Modules version if versioning enabled #if {![info exists ::env(MODULE_VERSION)]} { # setenv MODULE_VERSION 4.5.2 # setenv MODULE_VERSION_STACK 4.5.2 #} # initialize MODULEPATH and LOADEDMODULES if found unset if {![info exists ::env(MODULEPATH)]} { setenv MODULEPATH {} } if {![info exists ::env(LOADEDMODULES)]} { setenv LOADEDMODULES {} } # initialize user environment if found undefined (both MODULEPATH and # LOADEDMODULES empty) if {$::env(MODULEPATH) eq {} && $::env(LOADEDMODULES) eq {}} { # set modpaths defined in modulespath config file if it exists, use file # in etcdir if it exists, dot file in initdir elsewhere set modulespath [expr {[file exists /etc/environment-modules/modulespath] ?\ {/etc/environment-modules/modulespath} : {/usr/share/Modules/init/.modulespath}}] if {[file readable $modulespath]} { set fdata [split [readFile $modulespath] \n] foreach fline $fdata { if {[regexp {^\s*(.*?)\s*(#.*|)$} $fline match patharg] == 1\ && $patharg ne {}} { eval cmdModuleUse --append [split $patharg :] } } } # source initialization modulerc if any and if no env already initialized # use initrc file in etcdir if any, modulerc file in initdir otherwise set initrc [expr {[file exists /etc/environment-modules/initrc] ? {/etc/environment-modules/initrc} :\ {/usr/share/Modules/init/modulerc}}] if {[file exists $initrc]} { cmdModuleSource $initrc } } # default MODULESHOME setenv MODULESHOME [getConf home] # define Modules init script as shell startup file if {[getConf set_shell_startup] && [isInList [list sh csh fish]\ $::g_shellType]} { # setup ENV variables to get module defined in sub-shells (works for # 'sh' and 'ksh' in interactive mode and 'sh' (zsh-compat), 'bash' and # 'ksh' (zsh-compat) in non-interactive mode. setenv ENV /usr/share/Modules/init/profile.sh setenv BASH_ENV /usr/share/Modules/init/bash } popMode } proc cmdModuleInit {args} { set init_cmd [lindex $args 0] set init_list [lrange $args 1 end] set notdone 1 set nomatch 1 reportDebug $args # Define startup files for each shell set files(csh) [list .modules .cshrc .cshrc_variables .login] set files(tcsh) [list .modules .tcshrc .cshrc .cshrc_variables .login] set files(sh) [list .modules .bash_profile .bash_login .profile .bashrc] set files(bash) $files(sh) set files(ksh) $files(sh) set files(fish) [list .modules .config/fish/config.fish] set files(zsh) [list .modules .zshrc .zshenv .zlogin] # Process startup files for this shell set current_files $files($::g_shell) foreach filename $current_files { if {$notdone} { set filepath $::env(HOME) append filepath / $filename reportDebug "Looking at $filepath" if {[file readable $filepath] && [file isfile $filepath]} { set newinit {} set thismatch 0 foreach curline [split [readFile $filepath] \n] { # Find module load/add command in startup file set comments {} if {$notdone && [regexp {^([ \t]*module[ \t]+(load|add)[\ \t]*)(.*)} $curline match cmd subcmd modules]} { set nomatch 0 set thismatch 1 regexp {([ \t]*\#.+)} $modules match comments regsub {\#.+} $modules {} modules # remove existing references to the named module from # the list Change the module command line to reflect the # given command switch -- $init_cmd { list { if {![info exists notheader]} { report "$::g_shell initialization file\ \$HOME/$filename loads modules:" set notheader 0 } report \t$modules } add { foreach newmodule $init_list { set modules [replaceFromList $modules $newmodule] } lappend newinit "$cmd$modules $init_list$comments" # delete new modules in potential next lines set init_cmd rm } prepend { foreach newmodule $init_list { set modules [replaceFromList $modules $newmodule] } lappend newinit "$cmd$init_list $modules$comments" # delete new modules in potential next lines set init_cmd rm } rm { set oldmodcount [llength $modules] foreach oldmodule $init_list { set modules [replaceFromList $modules $oldmodule] } set modcount [llength $modules] lappend newinit [expr {$modcount > 0 ?\ "$cmd$modules$comments" : [string trim $cmd]}] if {$oldmodcount > $modcount} { set notdone 0 } } switch { set oldmodule [lindex $init_list 0] set newmodule [lindex $init_list 1] set newmodules [replaceFromList $modules\ $oldmodule $newmodule] lappend newinit $cmd$newmodules$comments if {$modules ne $newmodules} { set notdone 0 } } clear { lappend newinit [string trim $cmd] } } } elseif {$curline ne {}} { # copy the line from the old file to the new lappend newinit $curline } } if {$init_cmd ne {list} && $thismatch} { reportDebug "Writing $filepath" if {[catch { set fid [open $filepath w] puts $fid [join $newinit \n] close $fid } errMsg ]} { reportErrorAndExit "Init file $filepath cannot be\ written.\n$errMsg" } } } } } # quit in error if command was not performed due to no match if {$nomatch && $init_cmd ne {list}} { reportErrorAndExit "Cannot find a 'module load' command in any of the\ '$::g_shell' startup files" } } # provide access to modulefile specific commands from the command-line, making # them standing as a module sub-command (see module procedure) proc cmdModuleResurface {cmd args} { reportDebug "cmd='$cmd', args='$args'" pushMode load pushCommandName $cmd # run modulefile command and get its result if {[catch {eval $cmd $args} res]} { # report error if any and return false reportError $res } else { # register result depending of return kind (false or text) switch -- $cmd { module-info { set ::g_return_text $res } default { if {$res == 0} { # render false if command returned false set ::g_return_false 1 } } } } popCommandName popMode } proc cmdModuleTest {args} { reportDebug "testing $args" pushMode test set first_report 1 foreach mod $args { lassign [getPathToModule $mod] modfile modname if {$modfile ne {}} { # only one separator lines between 2 modules if {$first_report} { displaySeparatorLine set first_report 0 } report "Module Specific Test for [sgr hi $modfile]:\n" execute-modulefile $modfile $modname $mod displaySeparatorLine } } popMode } proc cmdModuleClear {{doit {}}} { reportDebug "($doit)" # fetch confirmation if no arg passed and force mode disabled if {$doit eq {} && ![getForce]} { # ask for it if stdin is attached to a terminal if {![catch {fconfigure stdin -mode}]} { report "Are you sure you want to clear all loaded modules!? \[n\] " 1 flush $::reportfd } # fetch stdin content even if not attached to terminal in case some # content has been piped to this channel set doit [gets stdin] } # should be confirmed or forced to proceed if {[string equal -nocase -length 1 $doit y] || [getForce]} { set vartoclear [list LOADEDMODULES MODULES_LMALTNAME MODULES_LMCONFLICT\ MODULES_LMNOTUASKED MODULES_LMPREREQ _LMFILES_] # add any reference counter variable to the list to unset set vartoclear [concat $vartoclear [array names ::env -glob *_modshare]\ [array names ::env -glob MODULES_MODSHARE_*]] # unset all Modules runtime variables pushMode load foreach var $vartoclear { unset-env $var } popMode } else { reportInfo "Modules runtime information were not cleared" } } proc cmdModuleConfig {dump_state args} { # parse arguments set nameunset 0 switch -- [llength $args] { 1 { lassign $args name } 2 { lassign $args name value # check if configuration should be set or unset if {$name eq {--reset}} { set name $value set nameunset 1 unset value } } } reportDebug "dump_state='$dump_state', reset=$nameunset,\ name=[expr {[info exists name] ? "'$name'" : {<undef>}}], value=[expr\ {[info exists value] ? "'$value'" : {<undef>}}]" foreach option [array names ::g_config_defs] { lassign $::g_config_defs($option) confvar($option) defval\ conflockable($option) confvalid($option) vtrans set confval($option) [getConf $option <undef>] set confvtrans($option) {} for {set i 0} {$i < [llength $vtrans]} {incr i} { lappend confvtrans($option) [lindex $vtrans $i] [lindex\ $confvalid($option) $i] } } # catch any environment variable set for modulecmd run-time execution foreach runenvvar [array names ::env -glob MODULES_RUNENV_*] { set runenvconf [string tolower [string range $runenvvar 8 end]] set confval($runenvconf) [get-env $runenvvar] # enable modification of runenv conf set confvar($runenvconf) $runenvvar set confvalid($runenvconf) {} set conflockable($runenvconf) {} set confvtrans($runenvconf) {} } if {[info exists name] && ![info exists confval($name)]} { reportErrorAndExit "Configuration option '$name' does not exist" # set configuration } elseif {[info exists name] && ($nameunset || [info exists value])} { if {$confvar($name) eq {}} { reportErrorAndExit "Configuration option '$name' cannot be altered" } elseif {$conflockable($name) eq {1} && [isConfigLocked $name]} { reportErrorAndExit "Configuration option '$name' is locked" } elseif {$nameunset} { # unset configuration variable pushMode load unsetenv $confvar($name) popMode } elseif {[llength $confvalid($name)] > 0 && [notInList\ $confvalid($name) $value]} { reportErrorAndExit "Valid values for configuration option '$name'\ are: $confvalid($name)" } else { # effectively set configuration variable pushMode load setenv $confvar($name) $value popMode } # clear cached value for config if any unsetConf $name # report configuration } else { reportVersion reportSeparateNextContent displayTableHeader hi {Config. name} 24 {Value (set by if default\ overridden)} 54 # report all configs or just queried one if {[info exists name]} { set varlist [list $name] } else { set varlist [lsort [array names confval]] } foreach var $varlist { set valrep [displayConfig $confval($var) $confvar($var) [info exists\ ::asked_$var] $confvtrans($var) [expr {$conflockable($var) eq {1}\ && [isConfigLocked $var]}]] append displist [format {%-25s %s} $var $valrep] \n } report $displist 1 reportSeparateNextContent if {$dump_state} { displayTableHeader hi {State name} 24 {Value} 54 # define each attribute/fetched state value pair set state_list [list\ cmdline "$::argv0 $::argv"\ extra_siteconfig_loaded [info exists ::g_extra_siteconfig_loaded]\ force [getForce]\ is_stderr_tty [isStderrTty]\ is_win [isWin]\ machine [uname machine]\ os "[uname sysname] [uname release]"\ pager_started $::start_pager\ paginate $::use_pager\ path_separator [getPathSeparator]\ rc_loaded [expr {[info exists ::g_rc_loaded] ? $::g_rc_loaded :\ {<undef>}}]\ siteconfig_loaded [info exists ::g_siteconfig_loaded]\ shell $::g_shell\ shelltype $::g_shellType\ subcmd $::command\ subcmd_args $::otherargv\ tcl_ext_lib_loaded [info exists ::g_tclextlib_loaded]\ tcl_version [info patchlevel]\ term_columns [getTtyColumns]] unset displist foreach {var val} $state_list { append displist [format {%-25s %s} $var $val] \n } report $displist 1 reportSeparateNextContent # report environment variable set related to Modules displayTableHeader hi {Env. variable} 24 {Value} 54 set envvar_list {} foreach var [list LOADEDMODULES _LMFILES_ MODULE* *_modshare\ *_modquar *_module*] { set envvar_list [concat $envvar_list [array names ::env -glob\ $var]] } unset displist foreach var [lsort -unique $envvar_list] { append displist [format {%-25s %s} $var $::env($var)] \n } report $displist 1 } } } proc cmdMlHelp {} { reportVersion report {Usage: ml [options] [command] [args ...] ml [options] [[-]modulefile ...] Examples: ml equivalent to: module list ml foo bar equivalent to: module load foo bar ml -foo -bar baz equivalent to: module unload foo bar; module load baz ml avail -t equivalent to: module avail -t See 'module --help' to get available commands and options.} } proc cmdModuleHelp {args} { pushMode help set first_report 1 foreach arg $args { lassign [getPathToModule $arg] modfile modname if {$modfile ne {}} { # only one separator lines between 2 modules if {$first_report} { displaySeparatorLine set first_report 0 } report "Module Specific Help for [sgr hi $modfile]:\n" execute-modulefile $modfile $modname $arg displaySeparatorLine } } popMode if {[llength $args] == 0} { reportVersion report {Usage: module [options] [command] [args ...] Loading / Unloading commands: add | load modulefile [...] Load modulefile(s) rm | unload modulefile [...] Remove modulefile(s) purge Unload all loaded modulefiles reload | refresh Unload then load all loaded modulefiles switch | swap [mod1] mod2 Unload mod1 and load mod2 Listing / Searching commands: list [-t|-l|-j] List loaded modules avail [-d|-L] [-t|-l|-j] [-S|-C] [--indepth|--no-indepth] [mod ...] List all or matching available modules aliases List all module aliases whatis [-j] [modulefile ...] Print whatis information of modulefile(s) apropos | keyword | search [-j] str Search all name and whatis containing str is-loaded [modulefile ...] Test if any of the modulefile(s) are loaded is-avail modulefile [...] Is any of the modulefile(s) available info-loaded modulefile Get full name of matching loaded module(s) Collection of modules handling commands: save [collection|file] Save current module list to collection restore [collection|file] Restore module list from collection or file saverm [collection] Remove saved collection saveshow [collection|file] Display information about collection savelist [-t|-l|-j] List all saved collections is-saved [collection ...] Test if any of the collection(s) exists Shell's initialization files handling commands: initlist List all modules loaded from init file initadd modulefile [...] Add modulefile to shell init file initrm modulefile [...] Remove modulefile from shell init file initprepend modulefile [...] Add to beginning of list in init file initswitch mod1 mod2 Switch mod1 with mod2 from init file initclear Clear all modulefiles from init file Environment direct handling commands: prepend-path [-d c] var val [...] Prepend value to environment variable append-path [-d c] var val [...] Append value to environment variable remove-path [-d c] var val [...] Remove value from environment variable Other commands: help [modulefile ...] Print this or modulefile(s) help info display | show modulefile [...] Display information about modulefile(s) test [modulefile ...] Test modulefile(s) use [-a|-p] dir [...] Add dir(s) to MODULEPATH variable unuse dir [...] Remove dir(s) from MODULEPATH variable is-used [dir ...] Is any of the dir(s) enabled in MODULEPATH path modulefile Print modulefile path paths modulefile Print path of matching available modules clear [-f] Reset Modules-specific runtime information source scriptfile [...] Execute scriptfile(s) config [--dump-state|name [val]] Display or set Modules configuration Switches: -t | --terse Display output in terse format -l | --long Display output in long format -j | --json Display output in JSON format -d | --default Only show default versions available -L | --latest Only show latest versions available -S | --starts-with Search modules whose name begins with query string -C | --contains Search modules whose name contains query string -i | --icase Case insensitive match -a | --append Append directory to MODULEPATH -p | --prepend Prepend directory to MODULEPATH --auto Enable automated module handling mode --no-auto Disable automated module handling mode -f | --force By-pass dependency consistency or confirmation dialog Options: -h | --help This usage info -V | --version Module version -D | --debug Enable debug messages -v | --verbose Enable verbose messages -s | --silent Turn off error, warning and informational messages --paginate Pipe mesg output into a pager if stream attached to terminal --no-pager Do not pipe message output into a pager --color[=WHEN] Colorize the output; WHEN can be 'always' (default if omitted), 'auto' or 'never'} } } ######################################################################## # main program # needed on a gentoo system. Shouldn't hurt since it is # supposed to be the default behavior fconfigure stderr -translation auto if {[catch { # parse all command-line arguments before doing any action, no output is # made during argument parse to wait for potential paging to be setup set show_help 0 set show_version 0 set command {} set otherargv {} reportDebug "CALLING $argv0 $argv" # Load extension library if enabled if {[file readable [getConf tcl_ext_lib]]} { reportDebug "Load Tcl extension library ([getConf tcl_ext_lib])" load [file normalize [getConf tcl_ext_lib]] Envmodules set g_tclextlib_loaded 1 } # use fallback procs if extension library is not loaded if {[info commands readFile] eq {}} { rename ::__readFile ::readFile rename ::__getFilesInDirectory ::getFilesInDirectory } # source site configuration script if any sourceSiteConfig # Parse shell set g_shell [lindex $argv 0] switch -- $g_shell { sh - bash - ksh - zsh { set g_shellType sh } csh - tcsh { set g_shellType csh } fish - cmd - tcl - perl - python - ruby - lisp - cmake - r { set g_shellType $g_shell } default { reportErrorAndExit "Unknown shell type \'($g_shell)\'" } } # extract options and command switches from other args set extraargv {} set ddelimarg 0 # split first arg if multi-word string detected for compat with previous # doc on module usage with scripting language: module('load mod1 mod2') set argtoparse [if {[llength [lindex $argv 1]] > 1} {concat [split [lindex\ $argv 1]] [lrange $argv 2 end]} {lrange $argv 1 end}] foreach arg $argtoparse { if {[info exists ignore_next_arg]} { unset ignore_next_arg } else { switch -glob -- $arg { -D - --debug { set asked_verbosity debug } -s - --silent { set asked_verbosity silent } -v - --verbose { set asked_verbosity verbose } --help - -h { set show_help 1 } -V - --version { set show_version 1 } --paginate { set asked_use_pager 1 } --no-pager { set asked_use_pager 0 } --auto { set asked_auto_handling 1 } --no-auto { set asked_auto_handling 0 } -f - --force { set asked_force 1 } --color* { set asked_color [string range $arg 8 end] if {$asked_color eq {}} { set asked_color always } elseif {[notInList [lindex $::g_config_defs(color) 3] $asked_color]} { unset asked_color } } -t - --terse - -l - --long - --default - -L - --latest - -S -\ --starts-with - -C - --contains - -j - --json { # command-specific switches that can for compatibility be # passed before the command name, so add them to a specific # arg list to ensure command name as first position argument lappend extraargv $arg } -d { # in case of *-path command, -d means --delim if {$ddelimarg} { lappend otherargv $arg } else { lappend extraargv $arg } } -a - --append - -append - -p - --prepend - -prepend - --delim -\ -delim - --delim=* - -delim=* - --duplicates - --index -\ --notuasked - --indepth - --no-indepth - --dump-state - --reset { # command-specific switches interpreted later on lappend otherargv $arg } append-path - prepend-path - remove-path { # detect *-path commands to say -d means --delim, not --default set ddelimarg 1 lappend otherargv $arg } -i - --icase { set asked_icase always } --human - -c - --create - --userlvl=* { # ignore C-version specific option, no error only warning reportWarning "Unsupported option '$arg'" } -u - --userlvl { reportWarning "Unsupported option '$arg'" # also ignore argument value set ignore_next_arg 1 } {-} - {--} - {--*} { reportErrorAndExit "Invalid option '$arg'\nTry 'module --help'\ for more information." } -* { # spare argument if ml command is called if {[lindex $otherargv 0] ne {ml}} { reportErrorAndExit "Invalid option '$arg'\nTry 'module\ --help' for more information." } else { lappend otherargv $arg } } default { lappend otherargv $arg } } } } set command [lindex $otherargv 0] set otherargv [concat [lreplace $otherargv 0 0] $extraargv] # call ml frontend if it is asked command if {$command eq {ml}} { set execcmdlist [concat [list ml] $otherargv] } else { set execcmdlist [concat [list module $command] $otherargv] } # now options are known initialize error report (start pager if enabled) initErrorReport # put back quarantine variables in env, if quarantine mechanism supported if {[getConf run_quarantine] ne {} && $g_shellType ne {csh}} { foreach var [split [getConf run_quarantine]] { # check variable name is valid if {[regexp {^[A-Za-z_][A-Za-z0-9_]*$} $var]} { set quarvar ${var}_modquar # put back value if {[info exists env($quarvar)]} { reportDebug "Release '$var' environment variable from\ quarantine ($env($quarvar))" set env($var) $env($quarvar) unset env($quarvar) # or unset env var if no value found in quarantine } elseif {[info exists env($var)]} { reportDebug "Unset '$var' environment variable after\ quarantine" unset env($var) } } elseif {[string length $var] > 0} { reportWarning "Bad variable name set in MODULES_RUN_QUARANTINE\ ($var)" } } } if {$show_help} { if {$command eq {ml}} { cmdMlHelp } else { cmdModuleHelp } cleanupAndExit 0 } if {$show_version} { reportVersion cleanupAndExit 0 } # no modulefile is currently being interpreted pushModuleFile {} # eval needed to pass otherargv as list to module proc eval $execcmdlist } errMsg ]} { # re-enable error report in case it was previously inhibited reenableErrorReport # remove any message record id to render next error clearAllMsgRecordId # render error if not done yet if {$errorCode ne {MODULES_ERR_RENDERED}} { raiseErrorCount renderFalse } # report stack trace in addition to the error message if error is unknown if {[notInList [list MODULES_ERR_RENDERED MODULES_ERR_KNOWN] $errorCode]} { set errMsg "$errorInfo\n[sgr hi {Please report this issue at\ https://github.com/cea-hpc/modules/issues}]" } reportError $errMsg # init error report here in case the error raised before the regular init initErrorReport cleanupAndExit 1 } cleanupAndExit 0 # ;;; Local Variables: *** # ;;; mode:tcl *** # ;;; End: *** # vim:set tabstop=3 shiftwidth=3 expandtab autoindent:
| ver. 1.1 | |
.
| PHP 8.3.30 | Ð“ÐµÐ½ÐµÑ€Ð°Ñ†Ð¸Ñ Ñтраницы: 0.1 |
proxy
|
phpinfo
|
ÐаÑтройка