#!/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-2022 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 . ########################################################################## # Runtime state properties (default value, proc to call to initialize state # value?) ##nagelfar ignore +31 Found constant array set g_state_defs [list\ autoinit {0}\ clock_seconds { initStateClockSeconds}\ domainname { {runCommand domainname}}\ error_count {0}\ extra_siteconfig_loaded {0}\ false_rendered {0}\ force {0}\ hiding_threshold {0}\ inhibit_errreport {0}\ inhibit_interp {0}\ init_error_report {0}\ is_stderr_tty { initStateIsStderrTty}\ is_win { initStateIsWin}\ kernelversion { {runCommand uname -v}}\ lm_info_cached {0}\ machine [list $::tcl_platform(machine)]\ nodename { {runCommand uname -n}}\ os [list $::tcl_platform(os)]\ osversion [list $::tcl_platform(osVersion)]\ paginate { initStatePaginate}\ path_separator { initStatePathSeparator}\ report_format {regular}\ reportfd {stderr initStateReportfd}\ return_false {0}\ siteconfig_loaded {0}\ shelltype { initStateShellType}\ sub1_separator {&}\ sub2_separator {|}\ tcl_ext_lib_loaded {0}\ tcl_version [list [info patchlevel]]\ term_columns { initStateTermColumns}\ timer {0}\ usergroups { initStateUsergroups}\ username { initStateUsername}\ ] # Configuration option properties (superseding environment variable, default # value, is configuration lockable to default value, value kind, valid value # list?, internal value representation?, proc to call to initialize option # value, valid value list kind ##nagelfar ignore #73 Too long line array set g_config_defs [list\ contact {MODULECONTACT root@localhost 0 s}\ auto_handling {MODULES_AUTO_HANDLING 1 0 b {0 1}}\ avail_indepth {MODULES_AVAIL_INDEPTH 1 0 b {0 1}}\ avail_output {MODULES_AVAIL_OUTPUT {modulepath:alias:dirwsym:sym:tag:variantifspec:key} 0 l {modulepath alias\ dirwsym sym tag key variant variantifspec} {} {} eltlist}\ avail_terse_output {MODULES_AVAIL_TERSE_OUTPUT {modulepath:alias:dirwsym:sym:tag:variantifspec} 0 l\ {modulepath alias dirwsym sym tag key variant variantifspec} {} {}\ eltlist}\ cache_buffer_bytes {MODULES_CACHE_BUFFER_BYTES 32768 0 i {4096 1000000} {}\ {} intbe}\ cache_expiry_secs {MODULES_CACHE_EXPIRY_SECS 0 0 i {0 31536000} {} {}\ intbe}\ collection_pin_version {MODULES_COLLECTION_PIN_VERSION 0 0 b {0 1}}\ collection_pin_tag {MODULES_COLLECTION_PIN_TAG 0 0 b {0 1}}\ collection_target {MODULES_COLLECTION_TARGET 0 s}\ color {MODULES_COLOR auto 0 s {never auto always} {0 1 2}\ initConfColor}\ colors {MODULES_COLORS {} 0 l {} {} initConfColors}\ csh_limit {{} 4000 0 i}\ extra_siteconfig {MODULES_SITECONFIG 1 s {}}\ editor {MODULES_EDITOR {vi} 0 s {} {} initConfEditor}\ home {MODULESHOME {/usr/share/Modules} 0 s}\ icase {MODULES_ICASE search 0 s {never search always}}\ ignore_cache {MODULES_IGNORE_CACHE 0 0 b {0 1}}\ ignore_user_rc {MODULES_IGNORE_USER_RC 0 0 b {0 1}}\ ignored_dirs {{} {CVS RCS SCCS .svn .git .SYNC .sos} 0 o}\ implicit_requirement {MODULES_IMPLICIT_REQUIREMENT 1 0\ b {0 1}}\ list_output {MODULES_LIST_OUTPUT {header:idx:variant:sym:tag:key} 0 l {header idx variant\ sym tag key} {} {} eltlist}\ list_terse_output {MODULES_LIST_TERSE_OUTPUT {header} 0 l\ {header idx variant sym tag key} {} {} eltlist}\ locked_configs {{} {} 0 o}\ mcookie_check {MODULES_MCOOKIE_CHECK always 0 s {eval always}}\ mcookie_version_check {MODULES_MCOOKIE_VERSION_CHECK\ 1 0 b {0 1}}\ ml {MODULES_ML 1 0 b {0 1}}\ nearly_forbidden_days {MODULES_NEARLY_FORBIDDEN_DAYS 14\ 0 i {0 365} {} {} intbe}\ pager {MODULES_PAGER {/usr/bin/less -eFKRX} 0 s}\ protected_envvars {MODULES_PROTECTED_ENVVARS 0 l}\ rcfile {MODULERCFILE 0 s}\ redirect_output {MODULES_REDIRECT_OUTPUT 1 0 b {0 1}}\ reset_target_state {MODULES_RESET_TARGET_STATE __init__ 0 s}\ quarantine_support {MODULES_QUARANTINE_SUPPORT 0 0 b {0\ 1}}\ run_quarantine {MODULES_RUN_QUARANTINE 0 o}\ shells_with_ksh_fpath {MODULES_SHELLS_WITH_KSH_FPATH {} 0 l {sh bash csh\ tcsh fish} {} {} eltlist}\ silent_shell_debug {MODULES_SILENT_SHELL_DEBUG 0 0 b {0\ 1}}\ siteconfig {{} {/etc/environment-modules/siteconfig.tcl} 0 s}\ tag_abbrev {MODULES_TAG_ABBREV {auto-loaded=aL:loaded=L:hidden=H:hidden-loaded=H:forbidden=F:nearly-forbidden=nF:sticky=S:super-sticky=sS:keep-loaded=kL} 0 l {} {} initConfTagAbbrev}\ tag_color_name {MODULES_TAG_COLOR_NAME {} 0 l {} {}\ initConfTagColorName}\ tcl_ext_lib {{} {} 0 s {} {} initConfTclExtLib}\ tcl_linter {MODULES_TCL_LINTER {nagelfar.tcl} 0 s}\ term_background {MODULES_TERM_BACKGROUND dark 0 s {dark light}}\ term_width {MODULES_TERM_WIDTH 0 0 i {0 1000} {} {} intbe}\ unload_match_order {MODULES_UNLOAD_MATCH_ORDER returnlast 0 s\ {returnlast returnfirst}}\ implicit_default {MODULES_IMPLICIT_DEFAULT 1 1 b {0 1}}\ extended_default {MODULES_EXTENDED_DEFAULT 1 0 b {0 1}}\ advanced_version_spec {MODULES_ADVANCED_VERSION_SPEC 1 0 b {0\ 1}}\ search_match {MODULES_SEARCH_MATCH starts_with 0 s {starts_with\ contains}}\ set_shell_startup {MODULES_SET_SHELL_STARTUP 0 0 b {0 1}}\ variant_shortcut {MODULES_VARIANT_SHORTCUT {} 0 l {} {}\ initConfVariantShortcut}\ verbosity {MODULES_VERBOSITY normal 0 s {silent concise normal\ verbose verbose2 trace debug debug2}}\ wa_277 {MODULES_WA_277 0 0 b {0 1}}\ ] # Get state value proc getState {state {valifundef {}} {catchinitproc 0}} { if {![info exists ::g_states($state)]} { # fetch state properties (including its default value) if defined if {[info exists ::g_state_defs($state)]} { lassign $::g_state_defs($state) value initproclist } else { set value set initproclist {} } # call specific proc to initialize state if any if {$initproclist ne {}} { # catch init procedure error and report it as warning, so default # value will get set for state if {$catchinitproc} { if {[catch {set value [{*}$initproclist]} errMsg]} { reportWarning $errMsg } } else { set value [{*}$initproclist] } # overridden value coming the command-line ##nagelfar ignore Suspicious variable } elseif {[info exists ::asked_$state]} { set value [set ::asked_$state] } # return passed value if undefined and no value record if {$value eq {}} { set value $valifundef } else { setState $state $value } return $value } else { return $::g_states($state) } } # Clear state proc unsetState {state} { if {[isStateDefined $state]} { unset ::g_states($state) reportDebug "$state unset" } } # Set state value proc setState {state value} { set ::g_states($state) $value reportDebug "$state set to '$value'" } # Append each passed value to the existing state value list proc lappendState {state args} { if {$state eq {-nodup}} { set state [lindex $args 0] # retrieve current val through getState to initialize it if still undef set value [getState $state] ##nagelfar ignore Found constant appendNoDupToList value {*}[lrange $args 1 end] setState $state $value } else { lappend ::g_states($state) {*}$args reportDebug "$state appended with '$args'" } } # Remove last element from state value list proc lpopState {state} { setState $state [lrange [getState $state] 0 end-1] } # Return first element from state value list proc topState {state} { return [lindex [getState $state] 0] } # Return last element from state value list proc currentState {state} { return [lindex [getState $state] end] } # Get number of element from state value list proc depthState {state} { return [llength [getState $state]] } # Check if state has been defined proc isStateDefined {state} { return [info exists ::g_states($state)] } # Check if state equals passed value proc isStateEqual {state value} { return [expr {[getState $state] eq $value}] } 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 valuekind\ validvallist intvallist initproc validvallistkind # 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 { # overridden value coming from environment if {$envvar ne {} && [info exists ::env($envvar)]} { switch -- $validvallistkind { eltlist { # ignore non-valid values if {![isDiffBetweenList [split $::env($envvar) :]\ $validvallist]} { set value $::env($envvar) } } intbe { # ignore non-valid values if {[string is integer -strict $::env($envvar)] &&\ $::env($envvar) >= [lindex $validvallist 0] &&\ $::env($envvar) <= [lindex $validvallist 1]} { set value $::env($envvar) } } {} { # ignore non-valid values ##nagelfar ignore +3 Non static subcommand if {[switch -- [llength $validvallist] { 0 {expr {1 == 1}} 1 {string is $validvallist -strict $::env($envvar)} default {expr {$::env($envvar) in $validvallist}} }]} { set value $::env($envvar) } } } } # overridden value coming the command-line (already validated) ##nagelfar ignore Suspicious variable if {[info exists ::asked_$option]} { set askedval [set ::asked_$option] # append or subtract value to existing configuration value if # new value starts with '+' or '-' (for colon-separated list # option only) if {$valuekind eq {l} && [string index $askedval 0] in {+ -}} { set curvaluelist [split $value :] switch -- [string index $askedval 0] { + { ##nagelfar ignore Found constant appendNoDupToList curvaluelist {*}[split [string\ range $askedval 1 end] :] } - { lassign [getDiffBetweenList $curvaluelist [split\ [string range $askedval 1 end] :]] curvaluelist } } set value [join $curvaluelist :] } else { set value $askedval } } # 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 {}} { 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] ##nagelfar ignore Found constant 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 } ##nagelfar ignore Found constant if {$siteconfig eq [getConf siteconfig]} { setState siteconfig_loaded 1 } else { setState extra_siteconfig_loaded 1 } } # check on extra_siteconfig after initial siteconfig loaded in case # it inhibits this extra load ##nagelfar ignore Found constant 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 initStateIsWin {} { return [expr {$::tcl_platform(platform) eq {windows}}] } # Get default path separator proc initStatePathSeparator {} { return [expr {[getState is_win] ? {;} : {:}}] } # Detect if terminal is attached to stderr message channel proc initStateIsStderrTty {} { return [expr {![catch {fconfigure stderr -mode}]}] } # Determine if pagination need to be started proc initStatePaginate {} { 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 paginate [expr {[file tail [lindex $pager 0]] ni $no_cmds}] # asked enablement could only nullify a previous asked disablement as it # requires a valid pager command configuration, which by default enables # pagination; some module command may also turn off pager; also if error # stream is not attached to a terminal set no_subcmds [list clear edit] if {$paginate && (([info exists ::asked_paginate] && !$::asked_paginate)\ || [getState subcmd] in $no_subcmds || ([getState subcmd] eq {ml} &&\ [lindex [getState subcmd_args] 0] in $no_subcmds) || ![getState\ is_stderr_tty])} { set paginate 0 } return $paginate } # start pager pipe process with defined configuration proc initStateReportfd {} { # get default value lassign $::g_state_defs(reportfd) reportfd # start pager at first call and only if enabled if {[getState paginate]} { if {[catch { set reportfd [open "|[getConf pager] >@stderr 2>@stderr" w] fconfigure $reportfd -buffering line -blocking 1 -buffersize 65536 } errMsg]} { # silently set reportfd to its fallback value to process warn msg set ::g_states(reportfd) $reportfd reportWarning $errMsg } } # startup content in case of structured output format (puts here rather # calling report proc to avoid infinite reportfd init loop if {[isStateEqual report_format json]} { puts -nonewline $reportfd \{ } return $reportfd } # Provide columns number for output formatting proc initStateTermColumns {} { set cols [getConf term_width] if {$cols == 0} { # determine col number from tty capabilities # 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 cols [expr {![info exists cols] || $cols eq {0} ? 80 : $cols}] } return $cols } # Deduce shelltype value from shell state value proc initStateShellType {} { switch -- [getState shell] { sh - bash - ksh - zsh { set shelltype sh } csh - tcsh { set shelltype csh } default { set shelltype [getState shell] } } return $shelltype } # Get all groups of user running modulecmd.tcl process proc __initStateUsergroups {} { # ensure groups including space in their name (found on Cygwin/MSYS # platforms) are correctly set as list element if {[catch { return [split [string range [runCommand id -G -n -z] 0 end-1] \0] } errMsg]} { # fallback if '-z' option is not supported return [runCommand id -G -n] } } # Get name of user running modulecmd.tcl process proc __initStateUsername {} { return [runCommand id -u -n] } # Get Epoch time (number of seconds elapsed since Unix epoch) proc __initStateClockSeconds {} { return [clock seconds] } # Initialize Select Graphic Rendition table proc initConfColors {envvar value validvallist intvallist} { # overridden value coming from environment if {[info exists ::env($envvar)]} { set colors_list $::env($envvar) if {[catch { # test overridden 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}} { ##nagelfar ignore Too long line set colors_list {hi=1:db=2:tr=2:se=2:er=31:wa=33:me=35:in=34:mp=1;34:di=34:al=36:va=33:sy=35:de=4:cm=32:aL=107:L=47:H=2:F=101:nF=103:S=106:sS=104:kL=48;5;109} } else { ##nagelfar ignore Too long line set colors_list {hi=1:db=2:tr=2:se=2:er=91:wa=93:me=95:in=94:mp=1;94:di=94:al=96:va=93:sy=95:de=4:cm=92:aL=100:L=90;47:H=2:F=41:nF=43:S=46:sS=44:kL=30;48;5;109} } 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} { # overridden 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 } # overridden value coming from environment via Modules-specific variable if {$envvar ne {} && [info exists ::env($envvar)]} { # ignore non-valid values if {[llength $validvallist] == 0 || $::env($envvar) in $validvallist} { set value $::env($envvar) } } # overridden 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 && (![getState is_stderr_tty] || $value == 2)} { incr value -1 } # initialize color theme if color mode enabled getConf colors return $value } # Initialize tcl_ext_lib configuration value proc initConfTclExtLib {envvar value validvallist intvallist} { set libfile libtclenvmodules.so # determine lib directory ##nagelfar ignore +13 Too long line #set libdir {@libdir@} switch -- [getState machine] { x86_64 - aarch64 - ppc64le - s390x { set libdirmain {/usr/lib64} set libdiralt {/usr/lib} } default { set libdirmain {/usr/lib} set libdiralt {/usr/lib64} } } # use alternative arch lib if available and not main one if {![file exists [file join $libdirmain $libfile]] && [file exists [file\ join $libdiralt $libfile]]} { set libdir $libdiralt } else { set libdir $libdirmain } return [file join $libdir $libfile] } # Initialize module tag abbreviation table proc initConfTagAbbrev {envvar value validvallist intvallist} { # overridden value coming from environment if {[info exists ::env($envvar)]} { if {[catch { # try to set the tag-abbreviation mapping table array set ::g_tagAbbrev [split $::env($envvar) {:=}] set value $::env($envvar) } errMsg ]} { reportWarning "Ignore invalid value set in $envvar ($::env($envvar))" array unset ::g_tagAbbrev } } # test default value if {![array exists ::g_tagAbbrev]} { if {[catch { array set ::g_tagAbbrev [split $value {:=}] } errMsg ]} { reportWarning "Ignore invalid default value for 'tag_abbrev' config\ ($value)" array unset ::g_tagAbbrev # define an empty list if no valid value set set value {} } } # build abbrev:tagname array foreach {tag abbrev} [array get ::g_tagAbbrev] { # skip tags not relevant for current command, that share their # abbreviation with another tag switch -- $tag { hidden-loaded { set setabbrevtag [expr {[currentState commandname] eq {list}}] } hidden { set setabbrevtag [expr {[currentState commandname] eq {avail}}] } default { set setabbrevtag 1 } } if {$setabbrevtag} { set ::g_abbrevTag($abbrev) $tag } } return $value } # Initialize module tag color name table proc initConfTagColorName {envvar value validvallist intvallist} { # overridden value coming from environment if {[info exists ::env($envvar)]} { set value $::env($envvar) } # set table for efficient search foreach tag [split $value :] { set ::g_tagColorName($tag) 1 } return $value } # Initialize interactive editor command proc initConfEditor {envvar value validvallist intvallist} { # overridden value coming from environment via Modules-specific variable if {$envvar ne {} && [info exists ::env($envvar)]} { set value $::env($envvar) # overridden value coming from environment via standard variable } elseif {[info exists ::env(VISUAL)]} { set value $::env(VISUAL) } elseif {[info exists ::env(EDITOR)]} { set value $::env(EDITOR) } return $value } # Initialize variant shortcut table proc initConfVariantShortcut {envvar value validvallist intvallist} { # overridden value coming from environment if {[info exists ::env($envvar)]} { if {[catch { # try to set the variant-shortcut mapping table array set testarr [split $::env($envvar) {:=}] set value $::env($envvar) set setfromenv 1 } errMsg ]} { reportWarning "Ignore invalid value set in $envvar ($::env($envvar))" } } # test default value if {![info exists setfromenv]} { if {[catch { array set testarr [split $value {:=}] } errMsg ]} { reportWarning "Ignore invalid default value for 'variant_shortcut'\ config ($value)" # define an empty list if no valid value set set value {} } } # ignore shortcut if not equal to one character or if set on alphanum char # or on char with special meaning foreach {vr sc} [split $value {:=}] { if {[string length $sc] == 1 && ![string match {[a-zA-Z0-9+~/@=-]}\ $sc]} { # remove duplicate shortcut or variant definition if {[info exists ::g_variantShortcut($vr)]} { unset ::g_shortcutVariant($::g_variantShortcut($vr)) } if {[info exists ::g_shortcutVariant($sc)]} { unset ::g_variantShortcut($::g_shortcutVariant($sc)) } set ::g_variantShortcut($vr) $sc set ::g_shortcutVariant($sc) $vr } } # update value after above filtering step set value {} foreach vr [array names ::g_variantShortcut] { if {[string length $value] > 0} { append value : } append value $vr=$::g_variantShortcut($vr) } 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) 4]\ [getConf verbosity]] >= [lsearch -exact [lindex\ $::g_config_defs(verbosity) 4] $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 {[currentState commandname] in [list avail list whatis search paths\ savelist]} { lappend enabledValList search } return [expr {[getConf icase] in $enabledValList}] } proc charEscaped {str {charlist { \\\t\{\}|<>!;#^$&*?"'`()}}} { return [regsub -all "$\[$charlist\]$" $str {\\\1}] } proc charUnescaped {str {charlist { \\\t\{\}|<>!;#^$&*?"'`()}}} { return [regsub -all "\\\\$\[$charlist\]$" $str {\1}] } proc strTo {lang str {esc 1}} { switch -- $lang { tcl { set enco \{; set encc \}} shell { set enco '; set encc '} } # escape all special characters if {$esc} { set str [charEscaped $str] } # enclose if empty or if contain a space character unless already escaped if {$str eq {} || (!$esc && [regexp {\s} $str])} { set str "$enco$str$encc" } return $str } proc listTo {lang lst {esc 1}} { set lout [list] # transform each list element foreach str $lst { lappend lout [strTo $lang $str $esc] } return [join $lout { }] } # 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 [exec $cmdpath {*}$args] } } proc getAbsolutePath {path} { # currently executing a modulefile or rc, so get the directory of this file if {[currentState modulefile] ne {}} { set curdir [file dirname [currentState modulefile]] # elsewhere get module command current working directory } else { # register pwd at first call if {![isStateDefined cwd]} { # raise a global known error if cwd cannot be retrieved (especially # when this directory has been removed) if {[catch {setState cwd [pwd]} errorMsg]} { knerror $errorMsg } } set curdir [getState cwd] } # empty result if empty path if {$path eq {}} { set abspath {} # consider path absolute if it starts with a variable ref } elseif {[string index $path 0] eq {$}} { set abspath $path } 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 [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 } # split string while ignore any separator character that is escaped 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 $idx-1] ne "\\"} { # unescape any separator character when adding to list lappend res [charUnescaped [string range $str $previdx+1 $idx-1]\ $sep] set previdx $idx } set idx [string first $sep $str $idx+1] } lappend res [charUnescaped [string range $str $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 } # 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 occurrences of passed character in passed string proc countChar {str char} { return [expr {[string length $str] - [string length [string map [list\ $char {}] $str]]}] } proc appendNoDupToList {lstname args} { set ret 0 upvar $lstname lst foreach elt $args { if {![info exists lst] || $elt ni $lst} { lappend lst $elt set ret 1 } } return $ret } proc replaceFromList {list1 item {item2 {}}} { while {[set xi [lsearch -exact $list1 $item]] >= 0} { ##nagelfar ignore #2 Badly formed if statement set list1 [if {[string length $item2] == 0} {lreplace $list1 $xi $xi}\ {lreplace $list1 $xi $xi $item2}] } return $list1 } # test if 2 lists have at least one element in common proc isIntBetweenList {list1 list2} { foreach elt $list1 { if {$elt in $list2} { return 1 } } return 0 } # test if 2 lists have at least one element in diff proc isDiffBetweenList {list1 list2} { foreach elt $list1 { if {$elt ni $list2} { return 1 } } return 0 } # 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 {$elt ni $list2} { lappend res1 $elt } } foreach elt $list2 { if {$elt ni $list1} { lappend res2 $elt } } return [list $res1 $res2] } # return intersection of all lists: elements present in every list proc getIntersectBetweenList {args} { foreach lst $args { if {![info exists res]} { set cur_res $lst } else { set cur_res [list] foreach elt $res { if {$elt in $lst} { lappend cur_res $elt } } } set res $cur_res # stop when intersection result becomes empty if {[llength $res] == 0} { break } } return $res } # return elements from arr1 not in arr2, elements from arr1 in arr2 but with a # different value and elements from arr2 not in arr1. # if notset_equals_empty is enabled, not-set element in array is equivalent to # element set to an empty value. # if unordered_lists_compared is enabled, value of array element is considered # a list and difference between list entries is made (order insensitive) proc getDiffBetweenArray {arrname1 arrname2 {notset_equals_empty 0}\ {unordered_lists_compared 0}} { upvar $arrname1 arr1 upvar $arrname2 arr2 set notin2 [list] set diff [list] set notin1 [list] foreach name [array names arr1] { # element in arr1 not in arr2 if {![info exists arr2($name)]} { if {!$notset_equals_empty} { lappend notin2 $name # if we consider a not-set entry equal to an empty value, there is a # difference only if entry in the other array is not empty } elseif {$arr1($name) ne {}} { lappend diff $name } # element present in both arrays but with a different value } elseif {!$unordered_lists_compared} { # but with a different value if {$arr1($name) ne $arr2($name)} { lappend diff $name } } else { # with a different value, not considering order lassign [getDiffBetweenList $arr1($name) $arr2($name)] notin2 notin1 if {([llength $notin2] + [llength $notin1]) > 0} { lappend diff $name } } } foreach name [array names arr2] { # element in arr2 not in arr1 if {![info exists arr1($name)]} { if {!$notset_equals_empty} { lappend notin1 $name } elseif {$arr2($name) ne {}} { lappend diff $name } } } return [list $notin2 $diff $notin1] } proc getCallingProcName {} { if {[info level] > 2} { set caller [lindex [info level -2] 0] } else { set caller {} } return $caller } proc raiseErrorCount {} { setState error_count [expr {[getState error_count] + 1}] } proc renderFalse {} { if {[isStateDefined false_rendered]} { reportDebug {false already rendered} # no shell code to render false if shell not set } elseif {[isStateDefined shell]} { # setup flag to render only once setState false_rendered 1 # render a false value most of the time through a variable assignment # 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 -- [getState shelltype] { sh - csh - fish { # no need to set a variable on real shells as last statement # result can easily be checked lappend ::g_shcode_out {test 0 = 1;} } tcl { lappend ::g_shcode_out {set _mlstatus 0;} } cmd { lappend ::g_shcode_out {set errorlevel=1} } perl { lappend ::g_shcode_out {{ no strict 'vars'; $_mlstatus = 0; }} } python { lappend ::g_shcode_out {_mlstatus = False} } ruby { lappend ::g_shcode_out {_mlstatus = false} } lisp { lappend ::g_shcode_out {nil} } cmake { lappend ::g_shcode_out {set(_mlstatus FALSE)} } r { lappend ::g_shcode_out {mlstatus <- FALSE} } } } } proc renderTrue {} { # render a true value most of the time through a variable assignment 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 -- [getState shelltype] { sh - csh - fish { # no need to set a variable on real shells as last statement # result can easily be checked lappend ::g_shcode_out {test 0;} } tcl { lappend ::g_shcode_out {set _mlstatus 1;} } cmd { lappend ::g_shcode_out {set errorlevel=0} } perl { lappend ::g_shcode_out {{ no strict 'vars'; $_mlstatus = 1; }} } python { lappend ::g_shcode_out {_mlstatus = True} } ruby { lappend ::g_shcode_out {_mlstatus = true} } lisp { lappend ::g_shcode_out {t} } cmake { lappend ::g_shcode_out {set(_mlstatus TRUE)} } r { lappend ::g_shcode_out {mlstatus <- TRUE} } } } proc renderText {text} { # render a text value most of the time through a variable assignment that # will be looked at in the shell module function calling modulecmd.tcl to # return in turns a string value. switch -- [getState shelltype] { sh - csh - fish { foreach word $text { # no need to set a variable on real shells, echoing text will make # it available as result lappend ::g_shcode_out "echo '$word';" } } tcl { lappend ::g_shcode_out "set _mlstatus \"$text\";" } cmd { foreach word $text { lappend ::g_shcode_out "echo $word" } } perl { lappend ::g_shcode_out "{ no strict 'vars'; \$_mlstatus = '$text'; }" } python { lappend ::g_shcode_out "_mlstatus = '$text'" } ruby { lappend ::g_shcode_out "_mlstatus = '$text'" } lisp { lappend ::g_shcode_out "(message \"$text\")" } cmake { lappend ::g_shcode_out "set(_mlstatus \"$text\")" } r { lappend ::g_shcode_out "mlstatus <- '$text'" } } } proc renderSettings {} { global g_stateEnvVars g_stateAliases g_stateFunctions g_stateCompletes\ g_newXResources g_delXResources g_shcode_out # preliminaries if there is stuff to render if {[getState autoinit] || [array size g_stateEnvVars] > 0 ||\ [array size g_stateAliases] > 0 || [array size g_newXResources] > 0 ||\ [array size g_stateFunctions] > 0 || [array size g_stateCompletes] > 0\ || [array size g_delXResources] > 0 || [info exists ::g_changeDir] ||\ [info exists ::g_stdoutPuts] || [info exists ::g_prestdoutPuts] ||\ [info exists ::g_return_text]} { switch -- [getState shelltype] { python { lappend g_shcode_out {import os} } } set has_rendered 1 } else { set has_rendered 0 } # send pre content deferred during modulefile interpretation if {[info exists ::g_prestdoutPuts]} { foreach {newline msg} $::g_prestdoutPuts { append outmsg $msg if {$newline} { lappend g_shcode_out $outmsg unset outmsg } } # add last remaining message if {[info exists outmsg]} { lappend g_shcode_out $outmsg } } if {[getState autoinit]} { renderAutoinit } # filter Modules-specific environment variables for mod-to-sh subcmd if {[getState modtosh_real_shell] ne {}} { foreach globvar [getModulesEnvVarGlobList 1] { foreach var [array names g_stateEnvVars -glob $globvar] { unset g_stateEnvVars($var) } } } # new environment variables foreach var [array names g_stateEnvVars] { switch -- $g_stateEnvVars($var) { new { switch -- [getState shelltype] { csh { set val [charEscaped $::env($var)] # csh barfs on long env vars if {[getState shell] eq {csh} && [string length $val] >\ [getConf csh_limit]} { if {$var eq {PATH}} { reportWarning "PATH exceeds [getConf csh_limit]\ characters, truncating and appending\ /usr/bin:/bin ..." set val [string range $val 0 [getConf\ csh_limit]-1]:/usr/bin:/bin } else { reportWarning "$var exceeds [getConf csh_limit]\ characters, truncating..." set val [string range $val 0 [getConf csh_limit]-1] } } lappend g_shcode_out "setenv $var $val;" } sh { lappend g_shcode_out "$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 } lappend g_shcode_out "set -xg $var $val;" } tcl { set val $::env($var) lappend g_shcode_out "set ::env($var) {$val};" } cmd { set val $::env($var) lappend g_shcode_out "set $var=$val" } perl { set val [charEscaped $::env($var) \'] lappend g_shcode_out "\$ENV{'$var'} = '$val';" } python { set val [charEscaped $::env($var) \'] lappend g_shcode_out "os.environ\['$var'\] = '$val'" } ruby { set val [charEscaped $::env($var) \'] lappend g_shcode_out "ENV\['$var'\] = '$val'" } lisp { set val [charEscaped $::env($var) \"] lappend g_shcode_out "(setenv \"$var\" \"$val\")" } cmake { set val [charEscaped $::env($var) \"] lappend g_shcode_out "set(ENV{$var} \"$val\")" } r { set val [charEscaped $::env($var) {\\'}] lappend g_shcode_out "Sys.setenv('$var'='$val')" } } } del { switch -- [getState shelltype] { csh { lappend g_shcode_out "unsetenv $var;" } sh { lappend g_shcode_out "unset $var;" } fish { lappend g_shcode_out "set -e $var;" } tcl { lappend g_shcode_out "catch {unset ::env($var)};" } cmd { lappend g_shcode_out "set $var=" } perl { lappend g_shcode_out "delete \$ENV{'$var'};" } python { lappend g_shcode_out "os.environ\['$var'\] = ''" lappend g_shcode_out "del os.environ\['$var'\]" } ruby { lappend g_shcode_out "ENV\['$var'\] = nil" } lisp { lappend g_shcode_out "(setenv \"$var\" nil)" } cmake { lappend g_shcode_out "unset(ENV{$var})" } r { lappend g_shcode_out "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 {[getState 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 -- [getState shelltype] { csh { set val [charEscaped $val] lappend g_shcode_out "alias $var $val;" } sh { set val [charEscaped $val] lappend g_shcode_out "alias $var=$val;" } fish { set val [charEscaped $val] lappend g_shcode_out "alias $var $val;" } cmd { lappend g_shcode_out "doskey $var=$val" } } } del { switch -- [getState shelltype] { csh { lappend g_shcode_out "unalias $var;" } sh { lappend g_shcode_out "unalias $var;" } fish { lappend g_shcode_out "functions -e $var;" } cmd { lappend g_shcode_out "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 -- [getState shell] { sh - ksh - zsh { lappend g_shcode_out "$funcname () { $val; };" } bash { lappend g_shcode_out "$funcname () { $val; }; export -f\ $funcname;" } fish { lappend g_shcode_out "function $funcname; $val; end;" } } } del { switch -- [getState shelltype] { sh { lappend g_shcode_out "unset -f $funcname;" } fish { lappend g_shcode_out "functions -e $funcname;" } } } } } foreach compname [array names g_stateCompletes] { switch -- $g_stateCompletes($compname) { new { foreach {compshell body} $::g_Completes($compname) { # skip definition not made for current shell if {$compshell eq [getState shell]} { switch -- [getState shell] { bash { lappend g_shcode_out "complete $body $compname;" } tcsh { lappend g_shcode_out "complete $compname $body;" } fish { # ensure pre-existing fish completion is cleared if {![info exists fishcompclear($compname)]} { lappend g_shcode_out "complete -e -c $compname;" set fishcompclear($compname) 1 } lappend g_shcode_out "complete -c $compname $body;" } } } } } del { switch -- [getState shell] { bash { lappend g_shcode_out "complete -r $compname;" } tcsh { lappend g_shcode_out "uncomplete $compname;" } fish { lappend g_shcode_out "complete -e -c $compname;" } } } } } # preliminaries for x-resources stuff if {[array size g_newXResources] > 0 || [array size g_delXResources] > 0} { switch -- [getState shelltype] { python { lappend g_shcode_out {import subprocess} } ruby { lappend g_shcode_out {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 -- [getState shelltype] { sh - csh - fish { lappend g_shcode_out "$xrdb -merge $var;" } tcl { lappend g_shcode_out "exec $xrdb -merge $var;" } perl { lappend g_shcode_out "system(\"$xrdb -merge $var\");" } python { set var [charEscaped $var \'] lappend g_shcode_out "subprocess.Popen(\['$xrdb',\ '-merge', '$var'\])" } ruby { set var [charEscaped $var \'] lappend g_shcode_out "Open3.popen2('$xrdb -merge $var')" } lisp { lappend g_shcode_out "(shell-command-to-string \"$xrdb\ -merge $var\")" } cmake { lappend g_shcode_out "execute_process(COMMAND $xrdb -merge\ $var)" } r { set var [charEscaped $var {\\'}] lappend g_shcode_out "system('$xrdb -merge $var')" } } } else { switch -- [getState shelltype] { sh - csh - fish { set var [charEscaped $var \"] set val [charEscaped $val \"] lappend g_shcode_out "echo \"$var: $val\" | $xrdb -merge;" } tcl { lappend g_shcode_out "set XRDBPIPE \[open \"|$xrdb -merge\"\ r+\];" set var [charEscaped $var \"] set val [charEscaped $val \"] lappend g_shcode_out "puts \$XRDBPIPE \"$var: $val\";" lappend g_shcode_out {close $XRDBPIPE;} lappend g_shcode_out {unset XRDBPIPE;} } perl { lappend g_shcode_out "open(XRDBPIPE, \"|$xrdb -merge\");" set var [charEscaped $var \"] set val [charEscaped $val \"] lappend g_shcode_out "print XRDBPIPE \"$var: $val\\n\";" lappend g_shcode_out {close XRDBPIPE;} } python { set var [charEscaped $var \'] set val [charEscaped $val \'] lappend g_shcode_out "subprocess.Popen(\['$xrdb',\ '-merge'\],\ stdin=subprocess.PIPE).communicate(input='$var:\ $val\\n')" } ruby { set var [charEscaped $var \'] set val [charEscaped $val \'] lappend g_shcode_out "Open3.popen2('$xrdb -merge') {|i,o,t|\ i.puts '$var: $val'}" } lisp { lappend g_shcode_out "(shell-command-to-string \"echo $var:\ $val | $xrdb -merge\")" } cmake { set var [charEscaped $var \"] set val [charEscaped $val \"] lappend g_shcode_out "execute_process(COMMAND echo \"$var:\ $val\" COMMAND $xrdb -merge)" } r { set var [charEscaped $var {\\'}] set val [charEscaped $val {\\'}] lappend g_shcode_out "system('$xrdb -merge', input='$var:\ $val')" } } } } } if {[array size g_delXResources] > 0} { ##nagelfar ignore Found constant 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 -- [getState shelltype] { sh - csh - fish { foreach var $xres_to_del { lappend g_shcode_out "echo \"$var:\" | $xrdb -merge;" } } tcl { foreach var $xres_to_del { lappend g_shcode_out "set XRDBPIPE \[open \"|$xrdb -merge\"\ r+\];" set var [charEscaped $var \"] lappend g_shcode_out "puts \$XRDBPIPE \"$var:\";" lappend g_shcode_out {close $XRDBPIPE;} lappend g_shcode_out {unset XRDBPIPE;} } } perl { foreach var $xres_to_del { lappend g_shcode_out "open(XRDBPIPE, \"|$xrdb -merge\");" set var [charEscaped $var \"] lappend g_shcode_out "print XRDBPIPE \"$var:\\n\";" lappend g_shcode_out {close XRDBPIPE;} } } python { foreach var $xres_to_del { set var [charEscaped $var \'] lappend g_shcode_out "subprocess.Popen(\['$xrdb', '-merge'\],\ stdin=subprocess.PIPE).communicate(input='$var:\\n')" } } ruby { foreach var $xres_to_del { set var [charEscaped $var \'] lappend g_shcode_out "Open3.popen2('$xrdb -merge') {|i,o,t|\ i.puts '$var:'}" } } lisp { foreach var $xres_to_del { lappend g_shcode_out "(shell-command-to-string \"echo $var: |\ $xrdb -merge\")" } } cmake { foreach var $xres_to_del { set var [charEscaped $var \"] lappend g_shcode_out "execute_process(COMMAND echo \"$var:\"\ COMMAND $xrdb -merge)" } } r { foreach var $xres_to_del { set var [charEscaped $var {\\'}] lappend g_shcode_out "system('$xrdb -merge', input='$var:')" } } } } if {[info exists ::g_changeDir]} { switch -- [getState shelltype] { sh - csh - fish { lappend g_shcode_out "cd '$::g_changeDir';" } tcl { lappend g_shcode_out "cd \"$::g_changeDir\";" } cmd { lappend g_shcode_out "cd $::g_changeDir" } perl { lappend g_shcode_out "chdir '$::g_changeDir';" } python { lappend g_shcode_out "os.chdir('$::g_changeDir')" } ruby { lappend g_shcode_out "Dir.chdir('$::g_changeDir')" } lisp { lappend g_shcode_out "(shell-command-to-string \"cd\ '$::g_changeDir'\")" } r { lappend g_shcode_out "setwd('$::g_changeDir')" } } # cannot change current directory of cmake "shell" } # send content deferred during modulefile interpretation if {[info exists ::g_stdoutPuts]} { foreach {newline msg} $::g_stdoutPuts { append outmsg $msg if {$newline} { lappend g_shcode_out $outmsg unset outmsg } } # add last remaining message if {[info exists outmsg]} { lappend g_shcode_out $outmsg } } # if currently processing mod-to-sh subcmd, send shell code to the message # channel then reset code and shell state to get evaluation result shell # code on stdout channel if {[getState modtosh_real_shell] ne {}} { if {[info exists g_shcode_out]} { report [join $::g_shcode_out \n] unset g_shcode_out } setState shell [getState modtosh_real_shell] unsetState shelltype } # 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 {[getState error_count] > 0} { reportDebug "[getState error_count] error(s) detected." renderFalse } elseif {[getState return_false]} { reportDebug {false value should be returned.} renderFalse } elseif {$has_rendered} { # finish with true statement if something has been put renderTrue } } # Output all gathered shell code to stdout. This is a separate proc rather the # final code of renderSettings as such output is also done when exiting after # an error. Stdout is flushed from flushAndExit proc proc renderFlush {} { if {[info exists ::g_shcode_out]} { # required to work on cygwin, shouldn't hurt real linux fconfigure stdout -translation lf puts stdout [join $::g_shcode_out \n] } } proc renderAutoinit {} { # automatically detect which tclsh should be used for # future module commands set tclshbin [info nameofexecutable] # ensure script path is absolute set ::argv0 [getAbsolutePath $::argv0] ##nagelfar ignore #462 Close brace not aligned with line switch -- [getState 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'\"'\"' [getState shell] \\!*`;" : "eval\ \"`$tclshbin '\"'\"'$::argv0'\"'\"' [getState 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 {[getState shell] eq {zsh} ? {^^=} : {}}] # 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 "_module_raw() {" if {[getConf silent_shell_debug]} { 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;} } if {[getConf quarantine_support]} { append fdef " unset _mlre _mlIFS; if \[ -n \"\${IFS+x}\" \]; then _mlIFS=\$IFS; fi; IFS=' '; for _mlv in \${${wsplit}MODULES_RUN_QUARANTINE:-}; do" ##nagelfar ignore #4 Too long line append fdef { if [ "${_mlv}" = "${_mlv##*[!A-Za-z0-9_]}" ] && [ "${_mlv}" = "${_mlv#[0-9]}" ]; then if [ -n "$(eval 'echo ${'"$_mlv"'+x}')" ]; then _mlre="${_mlre:-}__MODULES_QUAR_${_mlv}='$(eval 'echo ${'"$_mlv"'}')' "; fi; _mlrv="MODULES_RUNENV_${_mlv}"; _mlre="${_mlre:-}${_mlv}='$(eval 'echo ${'"$_mlrv"':-}')' "; fi; done; if [ -n "${_mlre:-}" ]; then _mlre="${_mlre:-}__MODULES_QUARANTINE_SET=1 ";} append fdef "\n eval \"\$(eval \${${wsplit}_mlre} $tclshbin\ '$::argv0' [getState shell] '\"\$@\"')\"; else eval \"\$($tclshbin '$::argv0' [getState shell] \"\$@\")\"; fi;" } else { append fdef " eval \"\$($tclshbin '$::argv0' [getState shell] \"\$@\")\";" } append fdef { _mlstatus=$?;} if {[getConf quarantine_support]} { append fdef { if [ -n "${_mlIFS+x}" ]; then IFS=$_mlIFS; else unset IFS; fi; unset _mlre _mlv _mlrv _mlIFS;} } if {[getConf silent_shell_debug]} { append fdef { if [ -n "${_mlshdbg:-}" ]; then set -"$_mlshdbg"; fi; unset _mlshdbg;} } append fdef { return $_mlstatus;} # define both _module_raw and module functions in any cases to allow # content redirection when command-line switch is used (--redirect or # --no-redirect) # content is redirected by default when shell session is attached to # a terminal (non-terminal session are not redirected to avoid # breaking things like scp or sftp transfer) # use local/typeset variable in this context as we cannot unset it # afterward (since _module_raw should be the cmd to return status) set localcmd [expr {[getState shell] eq {ksh} ? {typeset} : {local}}] ##nagelfar ignore Unescaped close brace append fdef "\n};\nmodule() { $localcmd _mlredir=[getState is_stderr_tty];\n" append fdef { if [ -n "${MODULES_REDIRECT_OUTPUT+x}" ]; then if [ "$MODULES_REDIRECT_OUTPUT" = '0' ]; then _mlredir=0; elif [ "$MODULES_REDIRECT_OUTPUT" = '1' ]; then _mlredir=1; fi; fi; case " $@ " in *' --no-redirect '*) _mlredir=0 ;; *' --redirect '*) _mlredir=1 ;; esac; if [ $_mlredir -eq 0 ]; then _module_raw "$@"; else _module_raw "$@" 2>&1; fi;} append fdef "\n};" if {[getState shell] eq {bash}} { append fdef { export -f _module_raw; export -f module;} } if {[getConf ml]} { append fdef { ml() { module ml "$@"; };} if {[getState shell] eq {bash}} { append fdef { export -f ml;} } } } fish { set fdef "function _module_raw\n" if {[getConf quarantine_support]} { 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"__MODULES_QUAR_"$_mlv"='$$_mlv' " end set _mlrv "MODULES_RUNENV_$_mlv" set _mlre "$_mlre$_mlv='$$_mlrv' " end end if [ -n "$_mlre" ] set _mlre "env $_mlre __MODULES_QUARANTINE_SET=1" end} # use "| source -" rather than "eval" to be able # to redirect stderr after stdout being evaluated append fdef "\n eval \$_mlre $tclshbin \\'$::argv0\\' [getState\ shell] (string escape -- \$argv) | source -\n" } else { append fdef " eval $tclshbin \\'$::argv0\\' [getState shell]\ (string escape -- \$argv) | source -\n" } append fdef "end function module set _mlredir [getState is_stderr_tty] if set -q MODULES_REDIRECT_OUTPUT if \[ \"\$MODULES_REDIRECT_OUTPUT\" = '0' \] set _mlredir 0 else if \[ \"\$MODULES_REDIRECT_OUTPUT\" = '1' \] set _mlredir 1 end end if contains -- --no-redirect \$argv; or begin ; \[ \$_mlredir -eq 0\ \]; and not contains -- --redirect \$argv ; end _module_raw \$argv else _module_raw \$argv 2>&1 end end" if {[getConf ml]} { append fdef { function ml module ml $argv end} } } tcl { set fdef "proc module {args} {" if {[getConf quarantine_support]} { 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 "__MODULES_QUAR_${_mlv}=$::env($_mlv)" } set _mlrv "MODULES_RUNENV_${_mlv}" lappend _mlre [expr {[info exists ::env($_mlrv)] ?\ "${_mlv}=$::env($_mlrv)" : "${_mlv}="}] } } if {[llength $_mlre] > 0} { lappend _mlre "__MODULES_QUARANTINE_SET=1" set _mlre [linsert $_mlre 0 "env"] } }} } append fdef { set _mlstatus 1;} if {[getConf quarantine_support]} { append fdef "\n catch {exec {*}\$_mlre \"$tclshbin\"\ \"$::argv0\" \"[getState shell]\" {*}\$args 2>@stderr}\ script\n" } else { append fdef "\n catch {exec \"$tclshbin\" \"$::argv0\"\ \"[getState shell]\" {*}\$args 2>@stderr} script\n" } append fdef { eval $script; return $_mlstatus} append fdef "\n}" if {[getConf ml]} { append fdef { proc ml {args} { return [module ml {*}$args] }} } } cmd { reportErrorAndExit {No autoinit mode available for 'cmd' shell} } perl { set fdef "sub module {" if {[getConf quarantine_support]} { 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 .= "__MODULES_QUAR_${_mlv}='$ENV{$_mlv}' "; } my $_mlrv = "MODULES_RUNENV_$_mlv"; $_mlre .= "$_mlv='$ENV{$_mlrv}' "; } } if ($_mlre ne "") { $_mlre = "env ${_mlre}__MODULES_QUARANTINE_SET=1 "; } }} } append fdef { my $args = ''; if (@_ > 0) { $args = '"' . join('" "', @_) . '"'; } my $_mlstatus = 1;} if {[getConf quarantine_support]} { append fdef "\n eval `\${_mlre}$tclshbin '$::argv0' perl\ \$args`;\n" } else { 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 sys, re, subprocess def module(*arguments):} if {[getConf quarantine_support]} { 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['__MODULES_QUAR_' + _mlv] = os.environ[_mlv] _mlrv = 'MODULES_RUNENV_' + _mlv if _mlrv in os.environ: _mlre[_mlv] = os.environ[_mlrv] else: _mlre[_mlv] = '' _mlre['__MODULES_QUARANTINE_SET'] = '1'} } append fdef { ns = {}} if {[getConf quarantine_support]} { append fdef "\n out, err = subprocess.Popen(\['$tclshbin',\ '$::argv0', 'python'\] + list(arguments),\ stdout=subprocess.PIPE, stderr=subprocess.PIPE,\ env=_mlre).communicate()\n" } else { append fdef "\n out, err = subprocess.Popen(\['$tclshbin',\ '$::argv0', 'python'\] + list(arguments),\ stdout=subprocess.PIPE,\ stderr=subprocess.PIPE).communicate()\n" } append fdef { exec(out, ns) if '_mlstatus' in ns: _mlstatus = ns['_mlstatus'] else: _mlstatus = True if err.decode(): print(err.decode(), end='', file=sys.stderr) return _mlstatus} if {[getConf ml]} { append fdef { def ml(*arguments): return module('ml', *arguments) } } } ruby { set fdef {class ENVModule def ENVModule.module(*args)} if {[getConf quarantine_support]} { ##nagelfar ignore +7 Too long line 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 << "__MODULES_QUAR_" + _mlv + "='" + ENV[_mlv].to_s + "' " end _mlrv = 'MODULES_RUNENV_' + _mlv _mlre << _mlv + "='" + ENV[_mlrv].to_s + "' " end end unless _mlre.empty? _mlre = 'env ' + _mlre + '__MODULES_QUARANTINE_SET=1 ' 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} if {[getConf quarantine_support]} { ##nagelfar ignore +2 Suspicious # char append fdef "\n eval `#{_mlre}$tclshbin '$::argv0' ruby\ #{args}`\n" } else { 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 { if {[getConf quarantine_support]} { set pre_exec "\n execute_process(COMMAND \${_mlre} $tclshbin\ \"$::argv0\" cmake " } else { 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)} if {[getConf quarantine_support]} { 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}__MODULES_QUAR_${_mlv}=$ENV{${_mlv}};") endif() set(_mlrv "MODULES_RUNENV_${_mlv}") set(_mlre "${_mlre}${_mlv}=$ENV{${_mlrv}};") endif() endforeach() if (NOT "${_mlre}" STREQUAL "") set(_mlre "env;${_mlre}__MODULES_QUARANTINE_SET=1;") 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(...){" if {[getConf quarantine_support]} { ##nagelfar ignore +7 Too long line 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, "__MODULES_QUAR_", mlv, "='", Sys.getenv(mlv), "' ") } mlrv <- paste0('MODULES_RUNENV_', mlv) mlre <- paste0(mlre, mlv, "='", Sys.getenv(mlrv), "' ") } } if (mlre != '') { mlre <- paste0('env ', mlre, '__MODULES_QUARANTINE_SET=1 ') } }} } append fdef { arglist <- as.list(match.call()) arglist[1] <- 'r' args <- paste0('"', paste0(arglist, collapse='" "'), '"')} if {[getConf quarantine_support]} { append fdef "\n cmd <- paste(mlre, '$tclshbin', '\"$::argv0\"',\ args, sep=' ')\n" } else { 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 lappend ::g_shcode_out $fdef } 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 isProtectedEnvVar {var} { # return if var is protected by protected_envvars config return [expr {$var in [split [getConf protected_envvars] :]}] } proc set-env {var val} { set mode [currentState mode] reportDebug "$var=$val" if {![isProtectedEnvVar $var]} { # an empty string value means unsetting variable on Windows platform, so # call unset-env to ensure variable will not be seen defined yet raising # an error when trying to access it if {[getState is_win] && $val eq {}} { unset-env $var } else { 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 } } } else { reportWarning "Modification of protected environment variable $var\ ignored" } } 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 [currentState mode] reportDebug "$var (internal=$internal, val=$val)" if {![isProtectedEnvVar $var]} { # 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 } } else { reportWarning "Modification of protected environment variable $var\ ignored" } } proc getPushenvVarName {var} { return __MODULES_PUSHENV_${var} } proc getModshareVarName {var} { # no modshare variable for Modules-specific path variables as each entry # should be unique (no reference counting mechanism for these variables # expect for MODULEPATH) if {$var in {_LMFILES_ LOADEDMODULES} || [string equal -length 10\ __MODULES_ $var] || [string equal -length 8 MODULES_ $var]} { return {} # specific modshare variable use a Modules-specific prefix (rather suffix # that may lead to warning message for instance for DYLD-related variables) } else { return __MODULES_SHARE_${var} } } # 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) [getState path_separator]] # 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)] ||\ $refcount($elt) < 1} { 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 } # generate reference count value to export in user environment proc setReferenceCountRecordValue {sharevar countlist} { foreach {elt refcount} $countlist { # do not export elements with a reference count of 1 as no reference # count entry means a reference count of 1 # exception made for empty string which is recorded even for a single # reference count to be able to distinguish between an empty path # variable and a path variable with an empty string as unique element if {$refcount > 1 || $elt eq {}} { lappend reclist $elt $refcount } } if {[info exists reclist]} { set-env $sharevar [pjoin $reclist [getState path_separator]] # unset ref count var if found set whereas no counter should be recorded } elseif {[info exists ::env($sharevar)]} { unset-env $sharevar 1 } } proc unload-path {cmd mode dflbhv args} { reportDebug "($args) cmd=$cmd, mode=$mode, dflbhv=$dflbhv" lassign [parsePathCommandArgs $cmd $mode $dflbhv {*}$args] separator\ allow_dup idx_val ign_refcount bhv var path_list switch -- $bhv { noop { return [list $bhv $var] } append - prepend { # set paths instead of removing them add-path unload-path load $bhv $cmd $separator $var {*}$path_list return [list $bhv $var] } } # clean any previously defined pushenv stack unset-env [getPushenvVarName $var] 1 # no reference count management when no share variable is returned set isrefcount [expr {[set sharevar [getModshareVarName $var]] ne {}}] if {$isrefcount} { 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 [list $bhv $var] } # 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)]} { # unload value in any case if counter ignored (--ignore-refcount set) if {$ign_refcount} { set countarr($dir) 0 } else { incr countarr($dir) -1 } if {$countarr($dir) <= 0} { unset countarr($dir) set newcount 0 } else { set newcount $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 { lappend 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) lappend 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 {$i ni $del_idx_list} { 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] } if {$isrefcount} { setReferenceCountRecordValue $sharevar [array get countarr] } return [list $bhv $var] } proc add-path {cmd mode dflbhv args} { reportDebug "($args) cmd=$cmd, mode=$mode, dflbhv=$dflbhv" # may be called from unload-path where argument parsing was already done if {$cmd eq {unload-path}} { set path_list [lassign $args cmd separator var] set allow_dup 0 set ign_refcount 0 set bhv $dflbhv } else { lassign [parsePathCommandArgs $cmd $mode $dflbhv {*}$args] separator\ allow_dup idx_val ign_refcount bhv var path_list } # clean any previously defined pushenv stack unset-env [getPushenvVarName $var] 1 # no reference count management when no share variable is returned set isrefcount [expr {[set sharevar [getModshareVarName $var]] ne {}}] if {$isrefcount} { array set countarr [getReferenceCountArray $var $separator] } if {$bhv 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 {$bhv eq {prepend} ? "$dir$separator$val" :\ "$val$separator$dir"}] } else { set val $dir } } if {[info exists countarr($dir)]} { # do not increase counter if it is ignored (--ignore-refcount set) # unless if duplicate mode is enabled (--duplicates set) if {!$ign_refcount || $allow_dup} { incr countarr($dir) } } else { set countarr($dir) 1 } } set-env $var $val if {$isrefcount} { setReferenceCountRecordValue $sharevar [array get countarr] } 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 mode dflbhv args} { # parse argument list set next_is_delim 0 set next_is_ignored 0 set next_is_reset 0 set allow_dup 0 set idx_val 0 set ign_refcount 0 set bhv $dflbhv foreach arg $args { # everything passed after variable name is considered a value if {[info exists var]} { switch -- $arg { --append-on-unload - --prepend-on-unload { if {$cmd ne {remove-path}} { knerror "invalid option '$arg' for $cmd" } elseif {$mode ne {unload}} { # ignore value set after this argument if not unloading # unless if no list is already set for load mode if {[info exists val_raw_list]} { set next_is_ignored 1 } } else { set bhv [expr {$arg eq {--append-on-unload} ? {append} :\ {prepend}}] # if another argument is set, current value list will be # withdrawn to start from new list set after this argument set next_is_reset 1 } set bhvopt $arg } --remove-on-unload - --noop-on-unload { if {$cmd ne {remove-path}} { knerror "invalid option '$arg' for $cmd" } elseif {$mode eq {unload}} { set bhv [expr {$arg eq {--remove-on-unload} ? {remove} :\ {noop}}] } set bhvopt $arg } default { if {$next_is_reset} { set next_is_reset 0 set val_raw_list [list $arg] } elseif {!$next_is_ignored} { # set multiple passed values in a list lappend val_raw_list $arg } } } } else { switch -glob -- $arg { --index { if {$cmd ne {remove-path}} { reportWarning "--index option has no effect on $cmd" } else { set idx_val 1 } } --duplicates { # raise warning when option is used by remove-path if {$cmd eq {remove-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] } --ignore-refcount { set ign_refcount 1 } --append-on-unload - --prepend-on-unload - --remove-on-unload -\ --noop-on-unload { if {$cmd ne {remove-path}} { knerror "invalid option '$arg' for $cmd" } elseif {$mode eq {unload}} { switch -- [string range $arg 2 5] { noop { set bhv noop } remo { set bhv remove } appe { set bhv append } prep { set bhv prepend } } } set bhvopt $arg } -* { 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 [getState path_separator] } 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" } # some options cannot be mixed if {$idx_val != 0 && ([info exists bhvopt] && $bhvopt !=\ {--noop-on-unload})} { knerror "--index and $bhvopt options cannot be simultaneously set" } # 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 lappend val_list {*}[split $val $delim] } } reportDebug "(delim=$delim, allow_dup=$allow_dup, idx_val=$idx_val,\ ign_refcount=$ign_refcount, bhv=$bhv, var=$var, val=$val_list,\ nbval=[llength $val_list])" return [list $delim $allow_dup $idx_val $ign_refcount $bhv $var $val_list] } # get list of Modules-specific environment variable in glob form proc getModulesEnvVarGlobList {{loaded_ctx 0}} { set envvar_glob_list [list LOADEDMODULES _LMFILES_] # only return list of variables related to module loaded context if {$loaded_ctx} { lappend envvar_glob_list __MODULES_* } else { lappend envvar_glob_list MODULE* __MODULES_* *_module* } return $envvar_glob_list } # # 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} {caller _undef_}} { # get caller name if {$caller eq {_undef_} && $showcaller} { set caller [getCallingProcName] } lappend ::errreport_buffer [list reportDebug $message $showcaller $caller] } # regular procedure to use once error report is initialized proc __reportDebug {message {showcaller 1} {caller _undef_}} { # display active interp details if not the main one set prefix [currentState debug_msg_prefix] if {$caller eq {_undef_} && $showcaller} { set caller [getCallingProcName] } # display caller name as prefix if {$showcaller && $caller ne {}} { append prefix "$caller: " } 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 {![getState 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 {[currentState msgrecordid] ne {}} { recordMessage $msgsgr $recordtop # skip message report if silent } elseif {[isVerbosityLevel concise]} { # save error messages to render them all together in JSON format if {[isStateEqual report_format 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 {}} {title {Module ERROR}}} { if {$modfile ne {}} { append message "\nIn '$modfile'" } append message "\nPlease contact <[getConf contact]>" reportError $message 0 $title me } proc reportInfo {message {title INFO}} { if {[isVerbosityLevel normal]} { # use reportError for convenience but there is no error here reportError $message 0 $title in 0 } } proc reportTrace {message {title TRACE}} { if {[isVerbosityLevel trace]} { # use reportError for convenience but there is no error here reportError [sgr tr $message] 0 $title tr 0 } } proc reportTimer {message timestr start_us stop_us} { set elapsed_ms [expr {($stop_us - $start_us) / 1000.0}] report [sgr db "TIMER $message [format $timestr $elapsed_ms]"] 0 1 } # trace procedure execution start proc reportTraceExecEnter {cmdstring op} { reportDebug $cmdstring 1 [getCallingProcName] } # time procedure execution duration proc reportTimerExecEnter {cmdstring op} { uplevel 1 set proc_timer_start [clock microseconds] } proc reportTimerExecLeave {cmdstring code result op} { reportTimer $cmdstring {(%.3f ms)} [uplevel 1 set proc_timer_start]\ [clock microseconds] } # is currently active message record id at top level proc isMsgRecordIdTop {} { return [expr {[depthState msgrecordid] eq 1}] } # record messages on the eventual additional module evaluations that have # occurred during the current evaluation proc reportModuleEval {} { set evalid [currentState evalid] 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 msgrecidlist [lassign $contextevallist context] # skip context with no description title if {[info exists contexttitle($context)]} { # exclude hidden modules from report unless an high level of # verbosity is set if {[info exists ::g_moduleHiddenEval($evalid:$context)] &&\ ![isVerbosityLevel verbose2]} { lassign [getDiffBetweenList $msgrecidlist\ $::g_moduleHiddenEval($evalid:$context)] msgrecidlist } if {[llength $msgrecidlist] > 0} { set moddesiglist {} foreach msgrecid $msgrecidlist { lappend moddesiglist [getModuleDesignation $msgrecid] } reportInfo [join $moddesiglist] $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 {hidden 0}} { set recid [currentState msgrecordid] if {[info exists ::g_msgRecord($recid)]} { # skip message report if silent (report even if hidden as soon as msgs # are associated to hidden module evaluation) if {[isVerbosityLevel concise]} { set tty_cols [getState term_columns] set padding { } set dispmsg $header foreach msg $::g_msgRecord($recid) { # split lines if too large for terminal set first 1 set max_idx [tcl::mathfunc::max [expr {$tty_cols - [string length\ $padding]}] 1] 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 $cut_idx-1] set line [string range $line $cut_idx+1 end] } else { set lineadd $line } # skip empty line if {[string trim $lineadd] ne {}} { lappend linelist $lineadd } if {$first} { set first 0 incr max_idx -[string length $padding] if {$max_idx < 1} {set max_idx 1} } } } # 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 (excluding # dependency evaluations which are reported by triggering top evaluation) # if hidden flag is enabled report only if verbosity >= verbose2 } elseif {(!$hidden && ([isVerbosityLevel verbose] || ([isVerbosityLevel\ normal] && ([ongoingCommandName restore] || [ongoingCommandName source]\ || [ongoingCommandName reset] || [ongoingCommandName stash] ||\ [ongoingCommandName stashpop] || [ongoingCommandName cacheclear] ||\ [ongoingCommandName cachebuild]) && $recid eq [topState msgrecordid])))\ || ($hidden && [isVerbosityLevel verbose2])} { 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 {[depthState reportholdid] > 0} { lappend ::g_holdReport([currentState reportholdid]) [list\ reportSeparateNextContent] } else { setState report_sep_next 1 } } # save message for block rendering proc recordMessage {message {recordtop 0}} { lappend ::g_msgRecord([expr {$recordtop ? [topState msgrecordid] :\ [currentState msgrecordid]}]) $message } # check if some msg have been recorded for current evaluation proc isMsgRecorded {} { return [info exists ::g_msgRecord([currentState msgrecordid])] } # 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 [list {*}[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} {eval $cachecontent}] # 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 referring to or called by an unknown # procedure (ie. a modulecmd.tcl internal procedure) if {$cmd1 ne $unkcmd && ($cmdcaller in $filtercmdlist || $cmd1 in\ $filtercmdlist)} { 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 {$cmd in $filtercmdendlist} { 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 $lastnl+1 end] if {[string match { ("eval" body line*} $lastline]} { set errmsg [string replace $errmsg $lastnl $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 } # Test if color is enabled and passed sgrkey is defined and not null proc isSgrkeyColored {sgrkey} { return [expr {[getConf color] && [info exists ::g_colors($sgrkey)] &&\ $::g_colors($sgrkey) ne {}}] } # Select Graphic Rendition of a string with passed sgr keys (if color enabled) proc sgr {keylist str {himatchmap {}} {othkeylist {}}} { if {[getConf color]} { set sgrreset 22 foreach sgrkey $keylist { if {[info exists ::g_colors($sgrkey)]} { # track color key that have been used if {![info exists ::g_used_colors($sgrkey)]} { set ::g_used_colors($sgrkey) 1 } if {[info exists sgrset]} { append sgrset {;} } append sgrset $::g_colors($sgrkey) # if render bold or faint just reset that attribute, not all if {$sgrreset != 0 && $sgrset != 1 && $sgrset != 2} { set sgrreset 0 } } } if {[llength $othkeylist] == 0} { # highlight matching substring if {[llength $himatchmap] > 0} { set str [string map $himatchmap $str] } if {[info exists sgrset]} { set str "\033\[${sgrset}m$str\033\[${sgrreset}m" } } else { if {![info exists sgrset]} { set sgrset {} } else { append sgrset {;} } # determine each chunk where the other sgr keys apply set tagsgrlen [expr {int(ceil([string length $str]/[llength\ $othkeylist]))}] for {set i 0} {$i < [llength $othkeylist]} {incr i} { set idx [expr {$i*$tagsgrlen}] set sgrkey [lindex $othkeylist $i] lappend sgridxlist $idx $::g_colors($sgrkey) # track color key that have been used if {![info exists ::g_used_colors($sgrkey)]} { set ::g_used_colors($sgrkey) 1 } } # determine each chunk where the highlight applies set hiidxlist {} foreach {mstr sgrmstr} $himatchmap { set idx 0 while {$idx != -1} { if {[set idx [string first $mstr $str $idx]] != -1} { lappend hiidxlist $idx incr idx [string length $mstr] # add highlight end index unless if end of string if {$idx < [string length $str]} { lappend hiidxlist $idx } } } # no need to look at next match string if this one was found if {[llength $hiidxlist] > 0} { break } } # mix other sgr chunks with highlighted chunks to define sgr codes set i 0 set j 0 set sgridx [lindex $sgridxlist 0] set hiidx [lindex $hiidxlist 0] set hicur 0 set sgrcur {} set sgrrst {0;} while {$i < [llength $sgridxlist] || $j < [llength $hiidxlist]} { set sgrcode {} set cursgridx $sgridx # sgr chunk change if {$sgridx ne {} && ($hiidx eq {} || $sgridx <= $hiidx)} { incr i set sgrcur $sgrset[lindex $sgridxlist $i] set idx $sgridx if {$idx != 0} { append sgrcode $sgrrst } append sgrcode $sgrcur incr i set sgridx [lindex $sgridxlist $i] } # highlight change if {$hiidx ne {} && ($cursgridx eq {} || $hiidx <= $cursgridx)} { set idx $hiidx set hicur [expr {!$hicur}] if {$hicur} { if {$sgrcode ne {}} { append sgrcode {;} } append sgrcode $::g_colors(hi) # restore current sgr set to only clear highlight } elseif {$sgrcode eq {}} { append sgrcode $sgrrst $sgrcur } incr j set hiidx [lindex $hiidxlist $j] } elseif {$hicur} { append sgrcode {;} $::g_colors(hi) } lappend fullsgridxlist $idx $sgrcode } # reset sgr at end of string lappend fullsgridxlist [string length $str] 0 # apply defined sgr codes to the string set stridx 0 foreach {sgridx sgrcode} $fullsgridxlist { if {$sgridx != 0} { append sgrstr [string range $str $stridx $sgridx-1] } append sgrstr "\033\[${sgrcode}m" set stridx $sgridx } set str $sgrstr } } return $str } # Sort tags to return those matching defined sgr keys in a list up to a given # maxnb number and if tag not set to be displayed by its name. Other elements # are returned in a separate list proc getTagSgrForModname {keylist maxnb} { set sgrkeylist {} if {[getConf color]} { set otherlist {} foreach key $keylist { if {[info exists ::g_colors($key)] && ![info exists\ ::g_tagColorName($key)] && [llength $sgrkeylist] < $maxnb} { lappend sgrkeylist $key } else { lappend otherlist $key } } } else { set otherlist $keylist } return [list $sgrkeylist $otherlist] } # 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 && [depthState reportholdid] > 0} { lappend ::g_holdReport([currentState reportholdid]) [list report\ $message $nonewline $immed $padnl] } else { # produce blank line prior message if asked to if {[isStateDefined reportfd] && [isStateDefined report_sep_next]} { unsetState report_sep_next report [expr {[isStateEqual report_format 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 [getState reportfd] $message } else { puts [getState 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} { # use Tcl native string representation of list if {$cmd eq {-nativeargrep}} { set cmd [lindex $args 0] set cmdargs [lrange $args 1 end] } else { set cmdargs [listTo tcl $args 0] } set extratab [expr {[string length $cmd] < 8 ? "\t" : {}}] 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} { reportCmd {*}$cmdstring } proc reportVersion {} { report {Modules Release 5.3.0\ (2023-05-14)} } # disable error reporting (non-critical report only) unless debug enabled proc inhibitErrorReport {} { if {![isVerbosityLevel trace]} { setState inhibit_errreport 1 } } proc initProcReportTrace {type prc} { ##nagelfar ignore #7 Non static subcommand if {[isVerbosityLevel debug] && [getState timer]} { # time execution of procedure instead of regular debug report trace $type execution $prc enter reportTimerExecEnter trace $type execution $prc leave reportTimerExecLeave } elseif {[isVerbosityLevel debug2]} { # trace each procedure call trace $type execution $prc enter reportTraceExecEnter } } # init error report and output buffered messages proc initErrorReport {} { # ensure init is done only once if {![isStateDefined init_error_report]} { setState init_error_report 1 # 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 } # trigger pager start if something needs to be printed, to guaranty # reportDebug calls during pager start are processed in buffer mode if {[isVerbosityLevel debug]} { getState reportfd } # only report timing information in debug mode if timer mode is enabled if {[isVerbosityLevel debug] && ![getState timer]} { # replace report procedures used to buffer messages until error # report being initialized by regular report procedures # delete initial reportDebug proc after getState which needs it rename ::reportDebug {} rename ::__reportDebug ::reportDebug } else { rename ::reportDebug {} # 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 # setup traces for either debug or timer reports if {[isVerbosityLevel debug] && [getState timer] || [isVerbosityLevel\ debug2]} { # list of core procedures to exclude from tracing set excl_prc_list [list report reportDebug reportFlush reportTimer\ reportTraceExecEnter reportTimerExecEnter reportTimerExecLeave\ initProcReportTrace isVerbosityLevel reportSeparateNextContent\ getState setState unsetState lappendState lpopState currentState\ depthState isStateDefined isStateEqual sgr getConf setConf\ unsetConf lappendConf getCallingProcName] foreach prc [info procs] { if {$prc ni $excl_prc_list} { initProcReportTrace add $prc } } } # now error report is init output every message saved in buffer; first # message will trigger message paging configuration and startup unless # already done if debug mode enabled foreach errreport $::errreport_buffer { {*}$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) { {*}$repcall } } unset ::g_holdReport($holdid) } } } # final message output and reportfd flush and close proc reportFlush {} { # report execution time if asked if {[getState timer]} { reportSeparateNextContent reportTimer {Total execution took} {%.3f ms} $::timer_start [clock\ microseconds] } # finish output document if json format enabled if {[isStateEqual report_format 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 unsetState report_sep_next report \} } # close pager if enabled if {[isStateDefined reportfd] && ![isStateEqual reportfd stderr]} { catch {flush [getState reportfd]} catch {close [getState reportfd]} } } # check if element passed as argument (corresponding to a kind of information) # should be part of output content proc isEltInReport {elt {retifnotdef 1}} { # get config name relative to current sub-command and output format set conf [currentState commandname] if {[getState report_format] ne {regular}} { append conf _[getState report_format] } append conf _output set arrname ::g_$conf ##nagelfar vartype arrname varName if {[info exists ::g_config_defs($conf)]} { # build value cache if it does not exist yet if {![array exists $arrname]} { array set $arrname {} foreach confelt [split [getConf $conf] :] { ##nagelfar ignore Suspicious variable name set ${arrname}($confelt) 1 } } # check if elt is marked to be included in output ##nagelfar ignore Suspicious variable name set ret [info exists ${arrname}($elt)] } else { # return $retifnotdef (ok by default) in case no config option # corresponds to the current module sub-command and output format set ret $retifnotdef } return $ret } proc registerModuleDesignation {evalid mod vrlist taglist} { set ::g_moduleDesgination($evalid) [list $mod $vrlist $taglist] } proc getModuleDesignation {from {mod {}} {sgr 1}} { # fetch module name version and variants from specified context switch -- $from { spec { set moddesig [getModuleNameAndVersFromVersSpec $mod] set vrlist [getVariantList $mod 7 0 1] set taglist {} } loaded { set moddesig $mod set vrlist [getVariantList $mod 7] set taglist {} } default { # fetch information from passed evaluation id if {[info exists ::g_moduleDesgination($from)]} { lassign $::g_moduleDesgination($from) moddesig vrlist taglist # if not found, use passed spec to compute designation } else { set moddesig [getModuleNameAndVersFromVersSpec $mod] set vrlist [getVariantList $mod 7 0 1] set taglist [getExportTagList $mod] } } } # build module designation switch -- $sgr { 2 { set vrsgr va set himatchmap [prepareMapToHightlightSubstr $moddesig] set showtags 1 # prepare list of tag abbreviations that can be substituted and list # of tags whose name should be colored getConf tag_abbrev getConf tag_color_name # abbreviate tags set taglist [abbrevTagList $taglist] } 1 { set vrsgr {se va} set himatchmap {} set showtags 0 } 0 { set vrsgr {} set himatchmap {} set showtags 0 } } lassign [formatListEltToDisplay $moddesig {} {} {} {} 0 0 $taglist\ $showtags $vrlist $vrsgr 1 $himatchmap] disp dispsgr displen return $dispsgr } # # 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: [join\ $modlist]" } proc getErrConflictMsg {conlist} { return "Module cannot be loaded due to a conflict.\n[getHintUnFirstMsg\ $conlist]" } proc getErrPrereqMsg {prelist {load 1}} { if {$load} { foreach pre $prelist { lappend predesiglist [getModuleDesignation spec $pre] } lassign [list {} missing [getHintLoFirstMsg $predesiglist]] un mis\ hintmsg } else { ##nagelfar ignore Found constant lassign [list un a [getHintUnFirstMsg $prelist]] un mis hintmsg } return "Module cannot be ${un}loaded due to $mis prereq.\n$hintmsg" } proc getErrReqLoMsg {prelist} { foreach pre $prelist { lappend predesiglist [getModuleDesignation spec $pre] } return "Load of requirement [join $predesiglist { or }] failed" } proc getReqNotLoadedMsg {prelist} { foreach pre $prelist { lappend predesiglist [getModuleDesignation spec $pre] } return "Requirement [join $predesiglist { or }] is not loaded" } proc getDepLoadedMsg {prelist} { set is [expr {[llength $prelist] > 1 ? {are} : {is}}] foreach pre $prelist { lappend predesiglist [getModuleDesignation loaded $pre] } return "Dependent [join $predesiglist { and }] $is loaded" } proc getErrConUnMsg {conlist} { set condesiglist {} foreach con $conlist { lappend condesiglist [getModuleDesignation spec $con] } return "Unload of conflicting [join $condesiglist { and }] failed" } proc getConIsLoadedMsg {conlist {loading 0}} { set is [expr {[llength $conlist] > 1 ? {are} : {is}}] set loaded [expr {$loading ? {loading} : {loaded}}] set condesiglist {} foreach con $conlist { lappend condesiglist [getModuleDesignation spec $con] } return "Conflicting [join $condesiglist { and }] $is $loaded" } proc getForbiddenMsg {mod} { set msg "Access to module [getModuleDesignation spec $mod 2] is denied" set extramsg [getModuleTagProp $mod forbidden message] if {$extramsg ne {}} { append msg \n$extramsg } return $msg } proc getNearlyForbiddenMsg {mod} { set after [getModuleTagProp $mod nearly-forbidden after] set msg "Access to module will be denied starting '$after'" set extramsg [getModuleTagProp $mod nearly-forbidden message] if {$extramsg ne {}} { append msg \n$extramsg } return $msg } proc getStickyUnloadMsg {{tag sticky}} { return "Unload of $tag module skipped" } proc getStickyForcedUnloadMsg {} { return {Unload of sticky module forced} } proc getModWithAltVrIsLoadedMsg {mod} { set vrdesiglist {} foreach vr [getVariantList $mod 1] { lappend vrdesiglist [sgr va $vr] } return "Variant [sgr se "\{"][join $vrdesiglist [sgr se :]][sgr se "\}"]\ is already loaded" } proc getEmptyNameMsg {type} { return "Invalid empty $type name" } # # Stack of message recording/eval unique identifiers # proc pushMsgRecordId {recid {setmsgid 1}} { lappendState evalid $recid if {$setmsgid} { lappendState msgrecordid $recid } } proc popMsgRecordId {{setmsgid 1}} { lpopState evalid if {$setmsgid} { lpopState msgrecordid } } proc clearAllMsgRecordId {} { unsetState evalid unsetState msgrecordid } # # Format output text # # format an element with its syms for display in a list proc formatListEltToDisplay {elt eltsgr eltsuffix sym_list symsgr show_syms\ sgrdef tag_list show_tags vr_list vrsgr show_vrs {himatchmap {}}\ {himatcharrvrmap {}} {himatcharrvrvalmap {}}} { # fetch sgr codes from tags to apply directly on main element if {$show_tags && [llength $tag_list] > 0} { # if more codes than character in elt, additional codes apply to the # side tag list lassign [getTagSgrForModname $tag_list [string length $elt]] tagsgrlist\ tag_list } else { set tagsgrlist {} } # display default sym graphically over element name if {$show_syms} { if {[set defidx [lsearch -exact $sym_list default]] != -1 && $sgrdef} { set sym_list [lreplace $sym_list $defidx $defidx] lappend eltsgrlist de } } set displen 0 set disp $elt lappend eltsgrlist $eltsgr set dispsgr [sgr $eltsgrlist $elt $himatchmap $tagsgrlist] # enclose name between quotes if a space is found if {[string first { } $elt] != -1} { incr displen 2 set dispsgr '$dispsgr' } # append suffix append disp $eltsuffix append dispsgr $eltsuffix # format variant list if any if {$show_vrs && [llength $vr_list] > 0} { array set himatchvrvalarr $himatcharrvrvalmap array set himatchvrarr $himatcharrvrmap set commasgr [sgr se ,] set vrssgr "[sgr se \{]" set vrs \{ foreach vrspec $vr_list { lassign $vrspec vrname vrnameset vrvalues vrdflidx vrloadedidx\ loadedsgrkey array unset vrvalsgridx # apply sgr to default and loaded variant value if {$vrdflidx != -1} { lappend vrvalsgridx($vrdflidx) de } if {$vrloadedidx != -1} { lappend vrvalsgridx($vrloadedidx) $loadedsgrkey } set vrsgrvalues $vrvalues foreach vrvalidx [array names vrvalsgridx] { lset vrsgrvalues $vrvalidx [sgr $vrvalsgridx($vrvalidx) [lindex\ $vrvalues $vrvalidx]] } if {[info exists notfirstvr]} { set colonsgr [sgr se :] append vrssgr $colonsgr append vrs : } else { set notfirstvr 1 } # highlight variant if corresponds to one set in query if {[info exists himatchvrarr($vrname)]} { set hivrmap $himatchvrarr($vrname) set hivrvalmap $himatchvrvalarr($vrname) } else { set hivrmap {} set hivrvalmap {} } if {[string length $vrnameset] > 0} { append vrssgr [sgr $vrsgr $vrnameset $hivrmap] } append vrssgr [sgr $vrsgr [lindex $vrsgrvalues 0] $hivrvalmap] foreach vrvalue [lrange $vrsgrvalues 1 end] { append vrssgr $commasgr[sgr $vrsgr $vrvalue $hivrvalmap] } append vrs $vrnameset[join $vrvalues :] } append vrssgr [sgr se \}] append vrs \} append dispsgr $vrssgr append disp $vrs } # format remaining sym list if {$show_syms && [llength $sym_list] > 0} { # track if a symbol has been reported excluding sym for alias '@' if {![info exists ::g_used_sym_nocolor] && ([llength $sym_list] > 1 || [lindex $sym_list 0] ne {@})} { set ::g_used_sym_nocolor 1 } append disp "([join $sym_list :])" set symssgr [sgr se (] foreach sym $sym_list { if {[info exists notfirstsym]} { if {![info exists colonsgr]} { set colonsgr [sgr se :] } append symssgr $colonsgr } else { set notfirstsym 1 } append symssgr [sgr $symsgr $sym] } append symssgr [sgr se )] append dispsgr $symssgr } # format tag list if any remaining if {$show_tags && [llength $tag_list] > 0} { append disp " <[join $tag_list :]>" set tagssgr " [sgr se <]" foreach tag $tag_list { # track tag name or abbreviation that have been used if {![info exists ::g_used_tags($tag)]} { set ::g_used_tags($tag) 1 } if {[info exists notfirsttag]} { if {![info exists colonsgr]} { set colonsgr [sgr se :] } append tagssgr $colonsgr } else { set notfirsttag 1 } # try to sgr in case a code apply to the tag append tagssgr [sgr $tag $tag] } append tagssgr [sgr se >] append dispsgr $tagssgr } # compute length incr displen [string length $disp] return [list $disp $dispsgr $displen] } # format an element with its syms for a long/detailed display in a list proc formatListEltToLongDisplay {elt eltsgr eltsuffix sym_list symsgr mtime\ sgrdef {himatchmap {}}} { # display default sym graphically over element name if {[set defidx [lsearch -exact $sym_list default]] != -1 && $sgrdef} { set sym_list [lreplace $sym_list $defidx $defidx] lappend eltsgrlist de } lappend eltsgrlist $eltsgr set displen 0 set disp $elt set dispsgr [sgr $eltsgrlist $elt $himatchmap] # enclose name between quotes if a space is found if {[string first { } $elt] != -1} { incr displen 2 set dispsgr '$dispsgr' } # append suffix append disp $eltsuffix append dispsgr $eltsuffix # compute length incr displen [string length $disp] # format remaining sym list if {[llength $sym_list] > 0} { set symslen [string length [join $sym_list :]] foreach sym $sym_list { if {![info exists colonsgr]} { set colonsgr [sgr se :] } else { append symssgr $colonsgr } append symssgr [sgr $symsgr $sym] } } else { set symssgr {} set symslen 0 } set nbws1 [expr {40 - $displen}] set nbws2 [expr {$nbws1 < 0 ? 20 - $symslen + $nbws1 : 20 - $symslen}] return [list $disp $dispsgr[string repeat { } $nbws1]$symssgr[string\ repeat { } $nbws2]$mtime $displen] } proc formatArrayValToJson {vallist} { return [expr {[llength $vallist] > 0 ? "\[ \"[join $vallist {", "}]\" \]"\ : {[]}}] } proc formatObjectValToJson {objlist} { foreach {key val isbool} $objlist { if {[info exists disp]} { append disp {, } } append disp "\"$key\": " if {$isbool} { append disp [expr {$val ? {true} : {false}}] } else { append disp "\"$val\"" } } ##nagelfar ignore Bad expression return [expr {[info exists disp] ? "{ $disp }" : "{}"}] } # format an element with its syms for a json display in a list proc formatListEltToJsonDisplay {elt args} { set disp "\"$elt\": \{ \"name\": \"$elt\"" foreach {key vtype val show} $args { if {!$show} { continue } append disp ", \"$key\": " switch -- $vtype { a {append disp [formatArrayValToJson $val]} o {append disp [formatObjectValToJson $val]} s {append disp "\"$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 highlight # rendering is disabled. proc prepareMapToHightlightSubstr {args} { set maplist {} if {[sgr hi {}] ne {}} { foreach substr $args { 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 } # Specific highlight translation map for variant name and value proc prepareMapToHightlightVariant {args} { set vrname_maplist {} set vrval_maplist {} if {[sgr hi {}] ne {}} { foreach modspec $args { foreach vrspec [getVariantListFromVersSpec $modspec] { lassign $vrspec vrname vrvalue vrisbool set maplist [list $vrname [sgr hi $vrname]] # also highlight shortcut if any if {[info exists ::g_variantShortcut($vrname)]} { lappend maplist $::g_variantShortcut($vrname) [sgr hi\ $::g_variantShortcut($vrname)] } lappend vrname_maplist $vrname $maplist # adapt variant value to highlight if boolean set maplist {} if {$vrisbool} { set vrshort [expr {$vrvalue ? {+} : {-}}]$vrname lappend maplist $vrshort [sgr hi $vrshort] set vrvalue [expr {$vrvalue ? {on} : {off}}] } lappend maplist $vrvalue [sgr hi $vrvalue] lappend vrval_maplist $vrname $maplist } } } return [list $vrname_maplist $vrval_maplist] } # Format list of modules obtained from a getModules call in upper context proc reportModules {search_queries header hsgrkey hstyle show_mtime show_idx\ one_per_line theader_cols excluded_tag {mod_list_order {}}} { # link to the result module list obtained in caller context upvar mod_list mod_list # output is JSON format set json [isStateEqual report_format json] # is some module variant specified in search query set variant_spec_in_query 0 foreach modspec $search_queries { if {[llength [getVariantListFromVersSpec $modspec]] > 0} { set variant_spec_in_query 1 break } } # elements to include in output set report_sym [isEltInReport sym] set report_tag [isEltInReport tag] set report_alias [isEltInReport alias] # enable variant report if variantifspec configured and some variant is # specified in query or variant configured for report or list sub-command # json output set report_variant [expr {($variant_spec_in_query && [isEltInReport\ variantifspec 0]) || [isEltInReport variant [expr {[currentState\ commandname] eq {list} && $json}]]}] set collect_variant_from [expr {[currentState commandname] eq {avail} ?\ {2} : {0}}] # prepare list of tag abbreviations that can be substituted and list of # tags whose name should be colored getConf tag_abbrev getConf tag_color_name # prepare results for display set alias_colored [isSgrkeyColored al] set default_colored [isSgrkeyColored de] set himatchmap [prepareMapToHightlightSubstr {*}$search_queries] lassign [prepareMapToHightlightVariant {*}$search_queries]\ himatcharrvrmap himatcharrvrvalmap set clean_list {} set vr_list {} # treat elements in specified order if any ##nagelfar ignore #2 Badly formed if statement foreach elt [if {[llength $mod_list_order] == 0} {array names mod_list}\ {set mod_list_order}] { if {$report_variant} { set vr_list [getVariantList $elt [expr {$json ? 4 : 7}] 0\ $collect_variant_from] } set sym_list [getVersAliasList $elt] # fetch tags but clear excluded tag set tag_list [replaceFromList [getTagList $elt] $excluded_tag] # abbreviate tags unless for json output if {!$json} { set tag_list [abbrevTagList $tag_list] } 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\ 1 symbols a $sym_list 1] } elseif {$show_mtime} { # append / char after name to clearly indicate this is a dir lassign [formatListEltToLongDisplay $elt di / $sym_list sy {}\ $default_colored $himatchmap] disp dispsgr displen } else { lassign [formatListEltToDisplay $elt di / $sym_list sy\ $report_sym $default_colored {} 0 {} {} 0 $himatchmap] disp\ dispsgr displen } } modulefile - virtual { if {$json} { set dispsgr [formatListEltToJsonDisplay $elt type s modulefile\ 1 variants o $vr_list $report_variant symbols a $sym_list 1\ tags a $tag_list 1 pathname s [lindex $mod_list($elt) 2] 1] } elseif {$show_mtime} { set clock_mtime [expr {[lindex $mod_list($elt) 1] ne {} ?\ [clock format [lindex $mod_list($elt) 1] -format {%Y/%m/%d\ %H:%M:%S}] : {}}] # add to display file modification time in addition # to potential syms lassign [formatListEltToLongDisplay $elt {} {} $sym_list sy\ $clock_mtime $default_colored $himatchmap] disp dispsgr\ displen } else { lassign [formatListEltToDisplay $elt {} {} $sym_list sy\ $report_sym $default_colored $tag_list $report_tag $vr_list\ va $report_variant $himatchmap $himatcharrvrmap\ $himatcharrvrvalmap] disp dispsgr displen } } alias { if {$json} { set dispsgr [formatListEltToJsonDisplay $elt type s alias 1\ symbols a $sym_list 1 tags a $tag_list 1 target s [lindex\ $mod_list($elt) 1] 1] } elseif {$show_mtime} { lassign [formatListEltToLongDisplay $elt al " -> [lindex\ $mod_list($elt) 1]" $sym_list sy {} $default_colored\ $himatchmap] disp dispsgr displen } elseif {$report_alias} { # add a '@' sym to indicate elt is an alias if not colored if {!$alias_colored} { lappend sym_list @ # track use of '@' sym to add it to the output key if {![info exists ::g_used_alias_nocolor]} { set ::g_used_alias_nocolor 1 } } lassign [formatListEltToDisplay $elt al {} $sym_list sy\ $report_sym $default_colored $tag_list $report_tag {} {} 0\ $himatchmap] disp dispsgr displen } } } if {$dispsgr ne {}} { if {$json} { lappend clean_list $dispsgr } else { lappend clean_list $disp set sgrmap($disp) $dispsgr set lenmap($disp) $displen } } } set len_list {} set max_len 0 if {$json} { ##nagelfar ignore Found constant upvar 0 clean_list display_list if {![info exists display_list]} { set display_list {} } } else { set display_list {} # dictionary-sort results unless if output order is specified if {[llength $mod_list_order] == 0} { set clean_list [lsort -dictionary $clean_list] } foreach disp $clean_list { # compute display element length list on sorted result lappend display_list $sgrmap($disp) lappend len_list $lenmap($disp) if {$lenmap($disp) > $max_len} { set max_len $lenmap($disp) } } } # output table header if needed and not yet done if {[llength $display_list] > 0 && $show_mtime && ![isStateDefined\ theader_shown]} { setState theader_shown 1 displayTableHeader {*}$theader_cols } # output formatted elements displayElementList $header $hsgrkey $hstyle $one_per_line $show_idx 1\ $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 [getState term_columns] 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] set lrep [tcl::mathfunc::max [expr {($tty_cols - $len - 2)/2}] 1] set rrep [tcl::mathfunc::max [expr {$tty_cols - $len - 2 - $lrep}] 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\ start_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, start_idx=$start_idx" # end proc if no element are to print if {$elt_cnt == 0} { return } # output is JSON format set json [isStateEqual report_format 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 $start_idx 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 [getState term_columns] # 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 [tcl::mathfunc::max [expr {int(($tty_cols - \ $elt_prefix_len) / $max_len)}] 0] # 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 { ##nagelfar ignore Unknown variable set istart [expr {$col * $cur_rows}] # only remove width of elements from current col for {set row 0} {$row < ($i % $cur_rows)} {incr row} { ##nagelfar ignore Unknown variable 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 +$start_idx}]] } # 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 } # Report an output key to help understand what the SGR used on this output # correspond to proc displayKey {} { array set skipsgr [list hi 1 db 1 tr 1 se 1 er 1 wa 1 me 1 in 1 cm 1 va 1] array set typesgr [list mp modulepath di [list directory / 10] al\ module-alias sy [list {symbolic-version} [sgr se (][sgr se )] 18]\ de [list {default-version}]] set display_list {} set len_list {} foreach key [array names ::g_used_colors] { # sgr key matches a basic modulefile type if {[info exists typesgr($key)]} { # the way to describe key is already defined if {[llength $typesgr($key)] > 1} { lassign $typesgr($key) desc desctmp len set desc [string map [list [sgr $key $desc]] $desctmp] } else { set desc [lindex $typesgr($key) 0] } if {$key eq {sy} && [info exists ::g_used_sym_nocolor]} { unset ::g_used_sym_nocolor } # key is a tag abbreviation } elseif {[info exists ::g_abbrevTag($key)]} { set desc $::g_abbrevTag($key) # if not part of the ignored list, this key corresponds to a tag name } elseif {![info exists skipsgr($key)]} { set desc $key } if {[info exists desc]} { # define key description if {![info exists len]} { set len [string length $desc] set desc [sgr $key $desc] } lappend display_list $desc lappend len_list $len unset desc unset len } } # include var=val key if any other variant form is present in report if {![info exists ::g_used_va(val)] && [array exists ::g_used_va]} { set ::g_used_va(val) 1 } # add key for variant reports if {[info exists ::g_used_va(on)]} { lappend display_list "[sgr se \{][sgr va +variant][sgr se\ \}]=[sgr se \{][sgr va variant=on][sgr se \}]" lappend len_list 23 } if {[info exists ::g_used_va(off)]} { lappend display_list "[sgr se \{][sgr va -variant][sgr se\ \}]=[sgr se \{][sgr va variant=off][sgr se \}]" lappend len_list 24 } foreach sc [array names ::g_used_va] { if {$sc ni {on off val}} { lappend display_list "[sgr se \{][sgr va ${sc}value][sgr se\ \}]=[sgr se \{][sgr va $::g_used_va($sc)=value][sgr se \}]" lappend len_list [expr {17 + [string length $::g_used_va($sc)]}] } } # finish with variant=value entry as it is referred by other variant keys if {[info exists ::g_used_va(val)]} { lappend display_list "[sgr se \{][sgr va variant=value][sgr se \}]" lappend len_list 15 } # add key for alias if '@' put in parentheses if {[info exists ::g_used_alias_nocolor]} { lappend display_list "[sgr se (]@[sgr se )]=module-alias" lappend len_list 9 } # add key for symbolic version if any put in parentheses but no color if {[info exists ::g_used_sym_nocolor]} { lappend display_list "[sgr se (]symbolic-version[sgr se )]" lappend len_list 18 } # add key for module tag if any put in angle brackets if {[array exists ::g_used_tags]} { lappend display_list "[sgr se <]module-tag[sgr se >]" lappend len_list 12 } # report translation of each uncolored tag abbreviation that have been used foreach tag [array names ::g_used_tags] { if {![info exists ::g_used_colors($tag)] && [info exists\ ::g_abbrevTag($tag)]} { lappend display_list [sgr se <]$tag[sgr se >]=$::g_abbrevTag($tag) lappend len_list [expr {[string length $tag] + [string length\ $::g_abbrevTag($tag)] + 3}] } } # find largest element set max_len 0 foreach len $len_list { if {$len > $max_len} { set max_len $len } } if {[llength $display_list] > 0} { # display header report Key: # display key content displayElementList noheader {} {} 0 0 0 $display_list $len_list $max_len } } # 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 } # report linter output as error/warning messages proc displayLinterOutput {linter output} { switch -- $linter { nagelfar { # parsing linter output set report_list {} foreach line [split $output \n] { set firstword [string range $line 0 [string first { } $line]-1] switch -- $firstword { Checking - Parsing {} Line { # add message of previous line if any if {[info exists msg]} { lappend report_list $msg } # extract information from message line set colidx [string first : $line] set linenum [string trimleft [string range $line 5\ $colidx-1]] set severity [string index $line $colidx+2] switch -- $severity { W { set severity WARNING set sgrkey wa set raisecnt 0 } E { set severity ERROR set sgrkey er set raisecnt 1 } default { set severity NOTICE set sgrkey in set raisecnt 0 } } set msg [string range $line $colidx+4 end] # start recorded message properties lappend report_list $linenum $severity $sgrkey $raisecnt } default { # this line is continuing message started previously append msg \n[string trimleft $line] } } } # add message of last line if any if {[info exists msg]} { lappend report_list $msg unset msg } # report messages foreach {linenum severity sgrkey raisecnt mesg} $report_list { reportError $mesg 0 "[format %-7s $severity] line $linenum"\ $sgrkey $raisecnt } } default { reportError $output } } } proc reportMlUsage {} { 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 reportUsage {} { reportVersion ##nagelfar ignore #111 Too long line report {Usage: module [options] [command] [args ...] Loading / Unloading commands: add | load modulefile [...] Load modulefile(s) try-add | try-load modfile [...] Load modfile(s), no complain if not found add-any | load-any modfile [...] Load first available modulefile in list rm | unload modulefile [...] Remove modulefile(s) purge Unload all loaded modulefiles reload Unload then load all loaded modulefiles switch | swap [mod1] mod2 Unload mod1 and load mod2 refresh Refresh loaded module volatile components reset Restore initial environment Listing / Searching commands: list [-a] [-t|-l|-j] [-S|-C] [mod ...] List all or matching loaded modules avail [-a] [-t|-l|-j] [-S|-C] [-d|-L] [--indepth|--no-indepth] [mod ...] List all or matching available modules aliases [-a] List all module aliases whatis [-a] [-j] [modulefile ...] Print whatis information of modulefile(s) apropos | keyword | search [-a] [-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 [-a] [-t|-l|-j] [-S|-C] [collection ...] List all or matching saved collections is-saved [collection ...] Test if any of the collection(s) exists stash Save current environment and reset stashpop [stash] Restore then remove stash collection stashrm [stash] Remove stash collection stashshow [stash] Display information about stash collection stashclear Remove all stash collections stashlist List all stash collections 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 Module cache handling commands: cachebuild [modulepath ...] Create cache file for modulepath(s) cacheclear Delete cache file in enabled modulepath(s) 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 state [name] Display Modules state sh-to-mod shell shellscript [arg ...] Make modulefile from script env changes mod-to-sh shell modulefile [...] Make shell code from modulefile env changes edit modulefile Open modulefile in editor lint [-a] [modulefile ...] Check syntax of modulefile Switches: -t | --terse Display output in terse format -l | --long Display output in long format -j | --json Display output in JSON format -o LIST | --output=LIST Define elements to output on 'avail' or 'list' sub-commands in addition to module names (LIST is made of items like 'sym', 'tag', 'variant' or 'key' separated by ':') -a | --all Include hidden modules in search -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 (on 'use' sub-command) -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 --tag=LIST Apply tag to loading module on 'load', 'try-load', 'load-any' or 'switch' sub-commands (LIST is made of tag names separated by ':') --ignore-cache Ignore module cache --ignore-user-rc Skip evaluation of user-specific module rc file Options: -h | --help This usage info -V | --version Module version -D | --debug Enable debug messages -T | --trace Enable trace messages -v | --verbose Enable verbose messages -s | --silent Turn off error, warning and informational messages --timer Report execution times --paginate Pipe mesg output into a pager if stream attached to terminal --no-pager Do not pipe message output into a pager --redirect Send output to stdout (only for sh, bash, ksh, zsh and fish) --no-redirect Send output to stderr --color[=WHEN] Colorize the output; WHEN can be 'always' (default if omitted), 'auto' or 'never' -w COLS | --width=COLS Set output width to COLS columns.} } # create appropriate message and kind of report when a requirement is not # satisfied proc reportMissingPrereqError {curmodnamevr args} { set retisreqlo [isModuleEvaluated reqlo $curmodnamevr {*}$args] # report message on currently evaluated module message block if {![set retiseval [isModuleEvaluated any $curmodnamevr {*}$args]] ||\ [currentState msgrecordid] ne [topState msgrecordid] || !$retisreqlo} { # more appropriate msg if an evaluation was attempted or is by-passed set msg [expr {$retiseval || [getState force] ? [getReqNotLoadedMsg\ $args] : [getErrPrereqMsg $args]}] # still proceed if force mode enabled if {[getState force]} { 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 {[getState force]} { reportWarning $msg 1 } else { knerror $msg MODULES_ERR_GLOBALTOP } } } # create appropriate message and kind of report when a conflict is detected proc reportPresentConflictError {curmodnamevr mod isloading} { set retisconun [isModuleEvaluated conun $curmodnamevr $mod] # report message on currently evaluated module message block if {![set retiseval [isModuleEvaluated any $curmodnamevr $mod]] ||\ [currentState msgrecordid] ne [topState msgrecordid] || !$retisconun} { # more appropriate msg if an eval was attempted or is by-passed set msg [expr {$retiseval || [getState force] ? [getConIsLoadedMsg\ [list $mod] $isloading] : [getErrConflictMsg $mod]}] # still proceed if force mode enabled if {[getState force]} { reportWarning $msg # indicate message has already been reported lappend ::report_conflict([currentState evalid]) $mod } else { knerror $msg MODULES_ERR_GLOBAL } } } # # Tcl sub-interpreter management # # 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" } # Get identifier name of current Tcl modulefile interpreter. An interp is # dedicated to each mode/auto_handling option value/depth level of modulefile # interpretation proc getCurrentModfileInterpName {} { return __modfile_[currentState mode]_[getConf auto_handling]_[depthState\ modulename] } # synchronize environment variable change over all started sub interpreters proc interp-sync-env {op var {val {}}} { set envvar ::env($var) ##nagelfar vartype envvar varName # 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 {[getState is_win] || ![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 # and auto_handling enablement proc initModfileModeAliases {mode auto 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 versioncmp versioncmp getenv getenv\ getvariant getvariant 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 initStateIsWin 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 refresh\ scan} ##nagelfar ignore #41 Too long line array set g_modfilePerModeAliases { add-property {nop nop nop nop nop nop nop nop } always-load {always-load nop reportCmd nop nop nop nop always-load-sc} append-path {append-path append-path-un append-path append-path append-path edit-path-wh nop edit-path-sc} chdir {chdir nop reportCmd nop nop nop nop chdir-sc } complete {complete complete-un reportCmd nop nop nop complete complete-sc } conflict {conflict nop reportCmd nop nop nop nop conflict-sc } depends-on {prereqAllModfileCmd nop reportCmd nop nop nop nop prereq-all-sc} extensions {nop nop nop nop nop nop nop nop } family {family family-un reportCmd nop nop nop nop family-sc } module {module module reportCmd nop nop nop nop module-sc } module-alias {module-alias module-alias module-alias module-alias module-alias module-alias nop nop } module-log {nimp nimp reportCmd nop nop nop nop nop } module-trace {nimp nimp reportCmd nop nop nop nop nop } module-user {nimp nimp reportCmd nop nop nop nop nop } module-verbosity {nimp nimp reportCmd nop nop nop nop nop } module-version {module-version module-version module-version module-version module-version module-version nop nop } module-virtual {module-virtual module-virtual module-virtual module-virtual module-virtual module-virtual nop nop } module-forbid {module-forbid module-forbid module-forbid module-forbid module-forbid module-forbid nop nop } module-hide {module-hide module-hide module-hide module-hide module-hide module-hide nop nop } module-tag {module-tag module-tag module-tag module-tag module-tag module-tag nop nop } module-whatis {nop nop reportCmd nop nop module-whatis nop nop } prepend-path {prepend-path prepend-path-un prepend-path prepend-path prepend-path edit-path-wh nop edit-path-sc} prereq-all {prereqAllModfileCmd nop reportCmd nop nop nop nop prereq-all-sc} prereq-any {prereqAnyModfileCmd nop reportCmd nop nop nop nop prereq-sc } prereq {prereqAnyModfileCmd nop reportCmd nop nop nop nop prereq-sc } pushenv {pushenv pushenv-un pushenv pushenv pushenv pushenv-wh nop pushenv-sc } remove-path {remove-path remove-path-un remove-path remove-path remove-path edit-path-wh nop edit-path-sc} remove-property {nop nop nop nop nop nop nop nop } require-fullname {require-fullname nop reportCmd nop nop nop nop nop } set-alias {set-alias set-alias-un reportCmd nop nop nop set-alias set-alias-sc} set-function {set-function set-function-un reportCmd nop nop nop set-function set-function-sc} setenv {setenv setenv-un setenv setenv setenv setenv-wh nop setenv-sc } source-sh {source-sh source-sh-un source-sh-di nop nop nop source-sh source-sh } system {system system reportCmd nop nop nop nop nop } uncomplete {uncomplete nop reportCmd nop nop nop nop uncomplete-sc} unset-alias {unset-alias nop reportCmd nop nop nop nop unset-alias-sc} unset-function {unset-function nop reportCmd nop nop nop nop unset-function-sc} unsetenv {unsetenv unsetenv-un unsetenv unsetenv unsetenv unsetenv-wh nop unsetenv-sc } variant {variant variant variant variant variant variant-wh variant variant-sc } x-resource {x-resource x-resource reportCmd nop nop nop nop nop } } } # alias commands where interpreter ref should be passed as argument array set aliasesPassArg [list getvariant [list __itrp__] puts [list\ __itrp__] variant [list __itrp__]] # initialize list with all commands not dependent of the evaluation mode array set aliases $::g_modfileBaseAliases # add site-specific command aliases for modulefile interp if {[info exists ::modulefile_extra_cmds]} { if {[catch {array set aliases $::modulefile_extra_cmds} errorMsg]} { knerror "Invalid value '$::modulefile_extra_cmds' ($errorMsg)\nfor\ siteconfig variable 'modulefile_extra_cmds'" } } # 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 in {reportCmd nimp edit-path-wh edit-path-sc}} { set aliasesPassArg($alias) [list $alias] # prereq commands need auto_handling state as first arg } elseif {$mode eq {load} && $alias in {prereq prereq-any prereq-all\ depends-on}} { set aliasesPassArg($alias) [list 0 $auto] # associate a trace command if per-mode alias command is not reportCmd # in display mode (except for source-sh) } elseif {$mode eq {display} && $alias ne {source-sh}} { set traces($alias) reportCmdTrace } } } proc execute-modulefile {modfile modname modnamevrvar modspec {up_namevr 1}\ {fetch_tags 1}} { # link to modnamevr variable name from calling ctx if content update asked if {$up_namevr} { upvar $modnamevrvar modnamevr } else { set modnamevr $modnamevrvar } lappendState modulefile $modfile lappendState modulename $modname lappendState modulenamevr $modnamevr lappendState specifiedname $modspec set mode [currentState mode] lappendState debug_msg_prefix\ "\[#[depthState modulename]:$mode:$modname\] " # skip modulefile if interpretation has been inhibited if {[getState inhibit_interp]} { reportDebug "skipping $modfile" return 1 } reportTrace "'$modfile' as '$modname'" {Evaluate modulefile} # gather all tags of evaluated modulefile if {$fetch_tags} { cacheCurrentModules 0 collectModuleTags $modnamevr } # inform that access to module will be soon denied if {$mode ne {unload} && [isModuleTagged $modnamevr nearly-forbidden 1]} { reportWarning [getNearlyForbiddenMsg $modnamevr] set nearlyforbidwarn 1 # fail unload attempt if module is sticky, unless if forced or reloading # also fail unload if mod is super-sticky even if forced, unless reloading } elseif {$mode eq {unload}} { # when loaded, tags applies to mod name and version (not with variant) if {[isModuleTagged $modname super-sticky 1] && [currentState\ reloading_supersticky] ne $modname} { # restore changed states prior raising error lpopState debug_msg_prefix lpopState specifiedname lpopState modulename lpopState modulenamevr lpopState modulefile knerror [getStickyUnloadMsg super-sticky] } elseif {[isModuleTagged $modname sticky 1] && [currentState\ reloading_sticky] ne $modname && [currentState unloading_sticky] ne\ $modname} { if {[getState force]} { reportWarning [getStickyForcedUnloadMsg] } else { # restore changed states prior raising error lpopState debug_msg_prefix lpopState specifiedname lpopState modulename lpopState modulenamevr lpopState modulefile knerror [getStickyUnloadMsg] } } } if {![info exists ::g_modfileUntrackVars]} { # list variable that should not be tracked for saving array set ::g_modfileUntrackVars [list ModulesCurrentModulefile 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 [getCurrentModfileInterpName] # evaluation mode-specific configuration set autosuf [expr {[getConf auto_handling] ? {AH} : {}}] set dumpCommandsVN g_modfile${mode}${autosuf}Commands set aliasesVN g_modfile${mode}${autosuf}Aliases set aliasesPassArgVN g_modfile${mode}${autosuf}AliasesPassArg set tracesVN g_modfile${mode}${autosuf}Traces ##nagelfar ignore Suspicious variable name if {![info exists ::$aliasesVN]} { ##nagelfar vartype aliasesVN varName ##nagelfar vartype aliasesPassArgVN varName ##nagelfar vartype tracesVN varName initModfileModeAliases $mode [getConf auto_handling] $aliasesVN\ $aliasesPassArgVN $tracesVN } # variable to define in modulefile interp if {![info exists ::g_modfileBaseVars]} { # record module tool properties set ::g_modfileBaseVars [list ModuleTool Modules ModuleToolVersion\ {5.3.0}] if {[info exists ::modulefile_extra_vars]} { if {([llength $::modulefile_extra_vars] % 2) != 0} { knerror "Invalid value '$::modulefile_extra_vars' (list must have\ an even number of elements)\nfor siteconfig variable\ 'modulefile_extra_vars'" } foreach {var val} $::modulefile_extra_vars { if {[string first { } $var] != -1} { knerror "Invalid variable name '$var'\ndefined in siteconfig\ variable 'modulefile_extra_vars'" } } lappend ::g_modfileBaseVars {*}$::modulefile_extra_vars } } # create modulefile interpreter at first interpretation if {![interp exists $itrp]} { reportDebug "creating interp $itrp" interp create $itrp # initialize global static variables for modulefile interp foreach {var val} $::g_modfileBaseVars { interp eval $itrp set ::$var "{$val}" } # 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 vrspeclist "{[getVariantListFromVersSpec\ $modnamevr]}" ##nagelfar ignore +7 Suspicious # char set errorVal [interp eval $itrp { set modcontent [readModuleContent $::ModulesCurrentModulefile 1] if {$modcontent eq {}} { return 1 } info script $::ModulesCurrentModulefile # eval then call for specific proc depending mode under same catch set sourceFailed [catch { eval $modcontent # raise error if a variant specified is not defined in modulefile set vrerrlist {} foreach vrspec $vrspeclist { set vrname [lindex $vrspec 0] if {![info exists ::ModuleVariant($vrname)]} { lappend vrerrlist "Unknown variant '$vrname' specified" } } # report all unknown variants specified, raise error on last report # take caution with vrerrlist variable as we are in modfile eval ctx if {[info exists vrerrlist] && [llength $vrerrlist] > 0} { for {set i 0} {$i < ([llength $vrerrlist] - 1)} {incr i} { reportError [lindex $vrerrlist $i] } error [lindex $vrerrlist $i] {} MODULES_ERR_GLOBAL } 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 # on Darwin, error is different: no errorCode & return code set to 3 } elseif {$errorMsg eq {invoked "break" outside of a loop}\ || ($errorMsg eq {} && (![info exists ::errorInfo]\ || $::errorInfo eq {})) || (![info exists ::errorCode] &&\ $sourceFailed == 3)} { unset errorMsg # report load/unload/refresh evaluation break if verbosity level # >= normal, no error count raise during scan evaluation set mode [module-info mode] if {$mode in {load unload refresh} && [isVerbosityLevel normal]} { reportError {Module evaluation aborted} } elseif {$mode ne {scan}} { 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 [list {*}[info procs] {*}[info\ commands]]] return 1 } } else { unset errorMsg return 0 } }] # check if mod name version and variant has changed (default variant set) # update modnamevr if so and collect tags applying to new name if {$up_namevr} { set newmodnamevr "{$modname}" if {[set vr [getVariantList $modname 1]] ne {}} { append newmodnamevr " $vr" } if {$modnamevr ne $newmodnamevr} { set modnamevr_tag_list [getTagList $modnamevr] set modnamevr_extratag_list [getExtraTagList $modnamevr] lassign [parseModuleSpecification 0 0 0 0 {*}$newmodnamevr] modnamevr if {$fetch_tags} { collectModuleTags $modnamevr # set tags applying to previous name (without default variant set) # not to forget extra defined tags setModuleTag $modnamevr {*}$modnamevr_tag_list setModuleExtraTag $modnamevr {*}$modnamevr_extratag_list } } } # check if special tags now applies and require to raise an error if {$mode ne {unload}} { if {[isModuleTagged $modnamevr forbidden 1]} { set errorVal 1 reportError [getForbiddenMsg $modnamevr] } elseif {![info exists nearlyforbidwarn] && [isModuleTagged $modnamevr\ nearly-forbidden 1]} { reportWarning [getNearlyForbiddenMsg $modnamevr] } } reportDebug "exiting $modfile" lpopState debug_msg_prefix lpopState specifiedname lpopState modulename lpopState modulenamevr lpopState modulefile return $errorVal } # Smaller subset than main module load... This function runs modulerc and # .version files proc execute-modulerc {modfile modname modspec} { lappendState modulefile $modfile # push name to be found by module-alias and version lappendState modulename $modname lappendState specifiedname $modspec set ::ModulesVersion {} lappendState debug_msg_prefix "\[#[depthState modulename]:$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 versioncmp\ versioncmp is-loaded is-loaded is-used is-used module-version\ module-version module-alias module-alias module-virtual\ module-virtual module-forbid module-forbid module-hide module-hide\ module-tag module-tag module-info module-info\ reportInternalBug reportInternalBug setModulesVersion\ setModulesVersion readModuleContent readModuleContent\ formatErrStackTrace formatErrStackTrace] # add site-specific command aliases for modulerc interp if {[info exists ::modulerc_extra_cmds]} { if {[catch {array set ::g_modrcAliases $::modulerc_extra_cmds}\ errorMsg]} { knerror "Invalid value '$::modulerc_extra_cmds' ($errorMsg)\nfor\ siteconfig variable 'modulerc_extra_cmds'" } } # 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] # variable to define in modulerc interp set ::g_modrcBaseVars [list ModuleTool Modules ModuleToolVersion\ {5.3.0}] if {[info exists ::modulerc_extra_vars]} { if {([llength $::modulerc_extra_vars] % 2) != 0} { knerror "Invalid value '$::modulerc_extra_vars' (list must have\ an even number of elements)\nfor siteconfig variable\ 'modulerc_extra_vars'" } foreach {var val} $::modulerc_extra_vars { if {[string first { } $var] != -1} { knerror "Invalid variable name '$var'\ndefined in siteconfig\ variable 'modulerc_extra_vars'" } } lappend ::g_modrcBaseVars {*}$::modulerc_extra_vars } } # dedicate an interpreter per level of interpretation to have in case of # cascaded interpretations a specific interpreter per level set itrp __modrc_[depthState modulename] reportTrace '$modfile' {Evaluate modulerc} # create modulerc interpreter at first interpretation if {![interp exists $itrp]} { reportDebug "creating interp $itrp" interp create $itrp # initialize global static variables for modulerc interp foreach {var val} $::g_modrcBaseVars { interp eval $itrp set ::$var "{$val}" } # dump initial interpreter state to restore it before each modulerc # interpretation. 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 {}} # create an alias ModuleVersion on ModulesVersion interp eval $itrp {upvar 0 ::ModulesVersion ::ModuleVersion} ##nagelfar ignore +4 Suspicious # char 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 [list {*}[info procs] {*}[info\ commands]]] return 1 } else { # pass ModulesVersion value to main 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" } } lpopState debug_msg_prefix lpopState specifiedname lpopState modulename lpopState modulefile return $::ModulesVersion } # Save list of the defined procedure and the global variables with their # associated values set in sub 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 sub 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 aliasargs $aliasesPassArg($alias) # pass current itrp reference on special keyword if {[lindex $aliasargs 0] eq {__itrp__}} { lset aliasargs 0 $itrp } interp alias $itrp $alias {} $aliases($alias) {*}$aliasargs } else { interp alias $itrp $alias {} $aliases($alias) } } if {$fresh} { # trace each modulefile command call if verbosity is set to debug (when # higher verbosity level is set all cmds are already traced) and timer # mode is disabled if {[getConf verbosity] eq {debug} && ![getState timer]} { interp alias $itrp reportTraceExecEnter {} reportTraceExecEnter foreach alias [array names aliases] { # exclude internal commands expoxed to modulerc/file interpreter # exclude cachefile commands if {$alias ni {report reportDebug reportError reportWarning\ reportCmdTrace raiseErrorCount reportInternalBug\ formatErrStackTrace isVerbosityLevel modulefile-content\ modulerc-content modulefile-invalid limited-access-file\ limited-access-directory}} { interp eval $itrp [list trace add execution $alias enter\ reportTraceExecEnter] } } } } foreach alias [array names traces] { interp eval $itrp [list trace add execution $alias leave\ $traces($alias)] } } # Restore initial setup of sub 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 {}] } } ##nagelfar vartype aliasesVN varName ##nagelfar vartype aliasesPassArgVN varName ##nagelfar vartype tracesVN varName ##nagelfar vartype renameCmdsVN varName # 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)] } } } } } # # Modulefile Tcl commands # # 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 versioncmp {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 } } proc module-info {what {more {}}} { set mode [currentState mode] switch -- $what { mode { if {$more ne {}} { set command [currentState commandname] return [expr {$mode eq $more || ($more eq {remove} && $mode eq \ {unload}) || ($more eq {switch} && $command eq {switch}) ||\ ($more eq {nonpersist} && $mode eq {refresh})}] } else { return $mode } } command { set command [currentState commandname] if {$more eq {}} { return $command } else { return [expr {$command eq $more}] } } name { return [currentState modulename] } specified { return [currentState specifiedname] } shell { if {$more ne {}} { return [expr {[getState shell] eq $more}] } else { return [getState 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 {[getState shelltype] eq $more}] } else { return [getState 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 sym_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 $sym_list] == 0 && $modversion eq {default}} { set sym_list [getVersAliasList $modname] } return [join $sym_list :] } tags { # refresh mod name version and variant to correctly get all matching # tags (in case tags apply to specific module variant) set modname [currentState modulename] set vrlist [getVariantList $modname 1] if {[llength $vrlist] > 0} { lassign [parseModuleSpecification 0 0 0 0 $modname {*}$vrlist]\ modnamevr } else { set modnamevr $modname } collectModuleTags $modnamevr if {$more ne {}} { return [expr {$more in [getTagList $modnamevr]}] } else { return [getTagList $modnamevr] } } version { lassign [getModuleNameVersion $more 1] mod return [resolveModuleVersionOrAlias $mod [isIcase]] } loaded { lassign [getModuleNameVersion $more 1] mod return [getLoadedMatchingName $mod returnall] } usergroups { if {[getState is_win]} { knerror "module-info usergroups not supported on Windows platform" } else { if {$more ne {}} { return [expr {$more in [getState usergroups]}] } else { return [getState usergroups] } } } username { if {[getState is_win]} { knerror "module-info username not supported on Windows platform" } else { if {$more ne {}} { return [expr {[getState username] eq $more}] } else { return [getState username] } } } default { knerror "module-info $what not supported" return {} } } } proc module-whatis {args} { lappend ::g_whatis [join $args] return {} } # 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} { 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) [currentState modulefile] } 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) [currentState modulefile] return {} } # Parse date time argument value and translate it into epoch time proc __parseDateTimeArg {opt datetime} { if {[regexp {^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2})?$} $datetime match\ timespec]} { # time specification is optional if {$timespec eq {}} { append datetime T00:00 } # return corresponding epoch time return [clock scan $datetime -format %Y-%m-%dT%H:%M] } else { knerror "Incorrect $opt value '$datetime' (valid date time format is\ 'YYYY-MM-DD\[THH:MM\]')" } } # parse application criteria arguments and determine if command applies proc parseApplicationCriteriaArgs {aftbef nearsec args} { set otherargs {} # parse argument list foreach arg $args { if {[info exists nextargisval]} { ##nagelfar vartype nextargisval varName set $nextargisval $arg unset nextargisval } elseif {[info exists nextargisdatetime]} { ##nagelfar ignore Suspicious variable name set ${nextargisdatetime}raw $arg # get epoch time from date time argument value ##nagelfar vartype nextargisdatetime varName ##nagelfar ignore Unknown variable set $nextargisdatetime [parseDateTimeArg $prevarg $arg] unset nextargisdatetime } else { switch -- $arg { --after - --before { # treat --after/--before as regular content if disabled if {!$aftbef} { lappend otherargs $arg } else { set nextargisdatetime [string trimleft $arg -] } } --not-group - --not-user { if {[getState is_win]} { knerror "Option '$arg' not supported on Windows platform" } else { set nextargisval not[string range $arg 6 end]list } } default { lappend otherargs $arg } } set prevarg $arg } } if {[info exists nextargisval] || [info exists nextargisdatetime]} { knerror "Missing value for '$prevarg' option" } # does it apply to current user? set notuser [expr {[info exists notuserlist] && [getState username] in\ $notuserlist}] set notgroup [expr {[info exists notgrouplist] && [isIntBetweenList\ $notgrouplist [getState usergroups]]}] # does it apply currently? set isbefore [expr {[info exists before] && [getState clock_seconds] <\ $before}] set isafter [expr {[info exists after] && [getState clock_seconds] >=\ $after}] # are criteria met set apply [expr {!$notuser && !$notgroup && ($isbefore || $isafter ||\ (![info exists before] && ![info exists after]))}] # is end limit near ? set isnearly [expr {!$apply && !$notuser && !$notgroup && [info exists\ after] && !$isafter && [getState clock_seconds] >= ($after - $nearsec)}] if {![info exists afterraw]} { set afterraw {} } return [list $apply $isnearly $afterraw $otherargs] } proc setModspecTag {modspec tag {props {}}} { reportDebug "Set tag '$tag' with properties '$props' on module\ specification '$modspec'" # record tag list for mod root to optimize search set modroot [getModuleRootFromVersSpec $modspec] if {![info exists ::g_moduleTagRoot($modroot)]} { lappend ::g_moduleTagRoot($modroot) $tag set idx 0 set new 1 } else { set idx [lsearch -exact $::g_moduleTagRoot($modroot) $tag] if {$idx == -1} { set idx [llength $::g_moduleTagRoot($modroot)] lappend ::g_moduleTagRoot($modroot) $tag set new 1 } } # then record mod spec and props at idx defined for tag. new spec are # appended and firstly matching spec is returned with its props on search if {[info exists new]} { lappend ::g_moduleTagRootSpec($modroot) [list $modspec $props] } else { set tagrootlist [lindex $::g_moduleTagRootSpec($modroot) $idx] lappend tagrootlist $modspec $props lset ::g_moduleTagRootSpec($modroot) $idx $tagrootlist } } proc module-forbid {args} { # parse application criteria arguments to determine if command apply lassign [parseApplicationCriteriaArgs 1 [expr {[getConf\ nearly_forbidden_days] * 86400}] {*}$args] apply isnearly after\ otherargs # parse remaining argument list, do it even if command does not apply to # raise any command specification error foreach arg $otherargs { if {[info exists nextargisval]} { ##nagelfar vartype nextargisval varName set $nextargisval $arg unset nextargisval } else { switch -glob -- $arg { --nearly-message { set nextargisval nearlymessage } --message { set nextargisval message } -* { knerror "Invalid option '$arg'" } default { lappend modarglist $arg } } set prevarg $arg } } if {[info exists nextargisval]} { knerror "Missing value for '$prevarg' option" } if {![info exists modarglist]} { knerror {No module specified in argument} } # skip record if application criteria are not met if {$apply} { set proplist {} if {[info exists message]} { ##nagelfar ignore Found constant lappend proplist message $message } # record each forbid spec after parsing them foreach modarg [parseModuleSpecification 0 0 0 0 {*}$modarglist] { setModspecTag $modarg forbidden $proplist } } elseif {$isnearly} { ##nagelfar ignore Found constant lappend proplist after $after if {[info exists nearlymessage]} { ##nagelfar ignore Found constant lappend proplist message $nearlymessage } # record each nearly forbid spec after parsing them foreach modarg [parseModuleSpecification 0 0 0 0 {*}$modarglist] { setModspecTag $modarg nearly-forbidden $proplist } } } proc module-hide {args} { set hidinglvl 1 set hiddenloaded 0 # parse application criteria arguments to determine if command apply lassign [parseApplicationCriteriaArgs 1 0 {*}$args] apply isnearly after\ otherargs # parse remaining argument list, do it even if command does not apply to # raise any command specification error foreach arg $otherargs { switch -glob -- $arg { --hard { # hardened stealth set hidinglvl 2 } --soft { # soften level of camouflage set hidinglvl 0 } --hidden-loaded { # module should stay hidden once being loaded set hiddenloaded 1 } -* { knerror "Invalid option '$arg'" } default { lappend modarglist $arg } } } if {![info exists modarglist]} { knerror {No module specified in argument} } # skip hide spec record if application criteria are not met if {$apply} { # record each hide spec after parsing them foreach modarg [parseModuleSpecification 0 0 0 0 {*}$modarglist] { setModspecHidingLevel $modarg $hidinglvl if {$hiddenloaded} { setModspecTag $modarg hidden-loaded } } } } proc module-tag {args} { # parse application criteria arguments to determine if command apply lassign [parseApplicationCriteriaArgs 0 0 {*}$args] apply isnearly after\ otherargs # parse remaining argument list, do it even if command does not apply to # raise any command specification error foreach arg $otherargs { switch -glob -- $arg { -* { knerror "Invalid option '$arg'" } default { if {![info exists tag]} { set tag $arg } else { lappend modarglist $arg } } } } if {![info exists tag]} { knerror {No tag specified in argument} } if {![info exists modarglist]} { knerror {No module specified in argument} } if {$tag in [list loaded auto-loaded forbidden nearly-forbidden hidden\ hidden-loaded]} { knerror "'$tag' is a reserved tag name and cannot be set" } # skip tag record if application criteria are not met if {$apply} { # record each hide spec after parsing them foreach modarg [parseModuleSpecification 0 0 0 0 {*}$modarglist] { setModspecTag $modarg $tag } } } # parse arguments sent to the unsetenv modulefile command proc parseSetenvCommandArgs {mode dflbhv args} { set bhv $dflbhv foreach arg $args { switch -- $arg { --set-if-undef { if {$mode eq {load}} { set setifundef 1 } } default { if {![info exists var]} { set var $arg } elseif {![info exists val]} { set val $arg } else { # too much argument set wrongargnum 1 } } } } if {[info exists wrongargnum] || ![info exists var] || ![info exists\ val]} { knerror {wrong # args: should be "setenv ?--set-if-undef? var val"} } if {[info exists setifundef] && [info exists ::env($var)]} { set bhv noop } reportDebug "bhv=$bhv, var=$var, val=$val" return [list $bhv $var $val] } proc setenv {args} { lassign [parseSetenvCommandArgs load set {*}$args] bhv var val if {$bhv eq {set}} { # clean any previously defined reference counter array unset-env [getModshareVarName $var] 1 # clean any previously defined pushenv stack unset-env [getPushenvVarName $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 {args} { lassign [parseSetenvCommandArgs unload unset {*}$args] bhv var val # clean any existing reference counter array unset-env [getModshareVarName $var] 1 # clean any previously defined pushenv stack unset-env [getPushenvVarName $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 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 {args} { lassign [parseSetenvCommandArgs load set {*}$args] bhv var val if {![info exists ::env($var)]} { set ::env($var) {} } return {} } # parse arguments sent to the getenv modulefile command proc parseGetenvCommandArgs {cmd args} { set returnval 0 set valifundef {} switch -- [llength $args] { 1 { set var [lindex $args 0] } 2 { switch -- [lindex $args 0] { --return-value { set returnval 1 set var [lindex $args 1] } default { set var [lindex $args 0] set valifundef [lindex $args 1] } } } 3 { if {[lindex $args 0] ne {--return-value}} { set wrongargs 1 } else { set returnval 1 set var [lindex $args 1] set valifundef [lindex $args 2] } } default { set wrongargs 1 } } set argname [expr {$cmd eq {getenv} ? {variable} : {name}}] if {[info exists wrongargs]} { knerror "wrong # args: should be \"$cmd ?--return-value? $argname\ ?valifundef?\"" } reportDebug "$argname='$var', valifundef='$valifundef',\ returnval='$returnval'" return [list $var $valifundef $returnval] } proc getenv {args} { # parse args lassign [parseGetenvCommandArgs getenv {*}$args] var valifundef returnval if {[currentState mode] ne {display} || $returnval} { return [get-env $var $valifundef] } else { return "\$$var" } } # parse arguments sent to the unsetenv modulefile command proc parseUnsetenvCommandArgs {mode dflbhv args} { foreach arg $args { switch -- $arg { --unset-on-unload { if {$mode eq {unload}} { set bhv unset } } --noop-on-unload { if {$mode eq {unload}} { set bhv noop } } default { if {![info exists var]} { set var $arg } elseif {![info exists val]} { set val $arg if {$mode eq {unload} && ![info exists bhv]} { set bhv set } } else { # too much argument set wrongargnum 1 } } } } if {[info exists wrongargnum] || ![info exists var]} { knerror {wrong # args: should be "unsetenv ?--noop-on-unload?\ ?--unset-on-unload? var ?val?"} } if {![info exists bhv]} { set bhv $dflbhv } # initialize val to always return same structure, val is only used if bhv # equals 'set' if {![info exists val]} { set val {} } reportDebug "bhv=$bhv, var=$var, val=$val" return [list $bhv $var $val] } proc unsetenv {args} { lassign [parseUnsetenvCommandArgs load unset {*}$args] bhv var val # clean any existing reference counter array unset-env [getModshareVarName $var] 1 # clean any previously defined pushenv stack unset-env [getPushenvVarName $var] 1 # Set the variable for later use during the modulefile evaluation unset-env $var return {} } # undo unsetenv in unload mode proc unsetenv-un {args} { lassign [parseUnsetenvCommandArgs unload noop {*}$args] bhv var val switch -- $bhv { set { # apply value specified for set on unload return [setenv $var $val] } unset { return [unsetenv $var] } noop { # otherwise just clear variable if it does not exist on unload mode # for later use during the modulefile evaluation if {![info exists ::env($var)]} { reset-to-unset-env $var } } } return {} } # optimized 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 unsetenv-wh {args} { lassign [parseUnsetenvCommandArgs load noop {*}$args] bhv var val if {![info exists ::env($var)]} { set ::env($var) {} } return {} } proc chdir {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 '[currentState modulename]'" } return {} } # supersede exit command to handle it if called within a modulefile # rather than exiting the whole process proc exitModfileCmd {{code 0}} { if {[currentState mode] in {load refresh}} { setState inhibit_interp 1 } # break to gently end interpretation of current modulefile return -code break } # enables sub interp to return ModulesVersion value to the main 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} { # determine if puts call targets the stdout or stderr channel switch -- [llength $args] { 1 { # create struct with newline status and message to output set deferPuts [list 1 [lindex $args 0]] } 2 { switch -- [lindex $args 0] { -nonewline { set deferPuts [list 0 [lindex $args 1]] } stdout { set deferPuts [list 1 [lindex $args 1]] } prestdout { set deferPrePuts [list 1 [lindex $args 1]] } stderr { set reportArgs [list [lindex $args 1]] } } } 3 { if {[lindex $args 0] eq {-nonewline}} { switch -- [lindex $args 1] { stdout { set deferPuts [list 0 [lindex $args 2]] } prestdout { set deferPrePuts [list 0 [lindex $args 2]] } 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]} { # current module is qualified for refresh evaluation lappendState -nodup refresh_qualified [currentState modulename] lappend ::g_stdoutPuts {*}$deferPuts } elseif {[info exists deferPrePuts]} { lappendState -nodup refresh_qualified [currentState modulename] lappend ::g_prestdoutPuts {*}$deferPrePuts # 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]} { 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 } } } proc prepend-path {args} { # Set the variable for later use during the modulefile evaluation add-path prepend-path load prepend {*}$args return {} } proc prepend-path-un {args} { # Set the variable for later use during the modulefile evaluation unload-path prepend-path unload remove {*}$args return {} } proc append-path {args} { # Set the variable for later use during the modulefile evaluation add-path append-path load append {*}$args return {} } proc append-path-un {args} { # Set the variable for later use during the modulefile evaluation unload-path append-path unload remove {*}$args return {} } proc remove-path {args} { # Set the variable for later use during the modulefile evaluation unload-path remove-path load remove {*}$args return {} } # undo remove-path in unload mode proc remove-path-un {args} { lassign [unload-path remove-path unload noop {*}$args] bhv var # clean any previously defined pushenv stack unset-env [getPushenvVarName $var] 1 # clear variable if it does not exist on unload mode for later use # during the modulefile evaluation 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 {cmd args} { # get variable name lassign [parsePathCommandArgs $cmd load noop {*}$args] separator allow_dup\ idx_val ign_refcount bhv var path_list if {![info exists ::env($var)]} { set ::env($var) {} } return {} } proc set-alias {alias what} { set ::g_Aliases($alias) $what set ::g_stateAliases($alias) new # current module is qualified for refresh evaluation lappendState -nodup refresh_qualified [currentState modulename] return {} } # undo set-alias in unload mode proc set-alias-un {alias what} { return [unset-alias $alias] } proc unset-alias {alias} { set ::g_Aliases($alias) {} set ::g_stateAliases($alias) del return {} } proc set-function {function what} { set ::g_Functions($function) $what set ::g_stateFunctions($function) new # current module is qualified for refresh evaluation lappendState -nodup refresh_qualified [currentState modulename] return {} } # undo set-function in unload mode proc set-function-un {function what} { return [unset-function $function] } proc unset-function {function} { set ::g_Functions($function) {} set ::g_stateFunctions($function) del return {} } proc is-loaded {args} { # parse module version specification set args [parseModuleSpecification 0 0 0 0 {*}$args] foreach mod $args { if {[getLoadedMatchingName $mod returnfirst] ne {}} { return 1 } } # is something loaded whatever it is? return [expr {[llength $args] == 0 && [llength\ [getLoadedModulePropertyList name]] > 0}] } proc is-loading {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} { set currentModule [currentState modulename] set curmodnamevr [currentState modulenamevr] # 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 [parseModuleSpecification 0 0 0 0 {*}$args] # register conflict list unless record inhibited for current iterp context if {[currentState inhibit_req_record] != [currentState evalid]} { 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 {![modEq $mod $currentModule eqstart 1 2 1] &&\ (!$isfullpath || ![modEq $mod $currentSModule eqstart 1 2 1]) &&\ [is-loading $mod]}] # if the conflicting module is loaded, we cannot either if {[is-loaded $mod] || $isloading} { reportPresentConflictError $curmodnamevr $mod $isloading } } return {} } proc parsePrereqCommandArgs {cmd args} { set tag_list {} set optional 0 set opt_list {} set prereq_list {} # parse options defined set i 0 foreach arg $args { if {[info exists nextargistaglist]} { set tag_list [split $arg :] lappend opt_list $arg unset nextargistaglist } else { switch -glob -- $arg { --optional { set optional 1 lappend opt_list $arg } --tag=* { set tag_list [split [string range $arg 6 end] :] lappend opt_list $arg if {[llength $tag_list] == 0} { knerror "Missing value for '--tag' option" } } --tag { set nextargistaglist 1 lappend opt_list $arg } -* { knerror "Invalid option '$arg'" } default { set prereq_list [lrange $args $i end] # end option parsing: remaining elts are list of prereqs break } } } incr i } foreach tag $tag_list { if {$tag in [list loaded auto-loaded forbidden nearly-forbidden\ hidden]} { knerror "Tag '$tag' cannot be manually set" } } if {[llength $prereq_list] == 0} { knerror "wrong # args: should be \"$cmd ?--optional? ?--tag? ?taglist?\ modulefile ?...?\"" } elseif {[set mispopt [lsearch -inline -glob $prereq_list --*]] ne {}} { knerror "Misplaced option '$mispopt'" } return [list $tag_list $optional $opt_list $prereq_list] } proc prereqAnyModfileCmd {tryload auto args} { lassign [parsePrereqCommandArgs prereq {*}$args] tag_list optional\ opt_list args set currentModule [currentState modulename] set curmodnamevr [currentState modulenamevr] # parse module version specification set args [parseModuleSpecification 0 0 0 0 {*}$args] # register prereq list (sets of optional prereq are registered as list) # unless record inhibited for current iterp context if {[currentState inhibit_req_record] != [currentState evalid]} { # if requirement is optional, add current module to the recorded prereq # list to make the requirement rule satisfied even if none loaded, as # current module will be loaded if {$optional} { lappend record_list $currentModule } lappend record_list {*}$args setLoadedPrereq $currentModule $record_list } if {$auto} { # try to load prereq as dependency resolving is enabled lassign [loadRequirementModuleList $tryload $optional $tag_list\ {*}$args] retlo prereqloaded } else { set loadedmod_list {} foreach mod $args { # get all loaded or loading mod in args list if {[set loadedmod [getLoadedMatchingName $mod returnfirst]] ne {}\ || [set loadedmod [getLoadedMatchingName $mod returnfirst 1]] ne\ {}} { lappend loadedmod_list $loadedmod } } set prereqloaded [expr {[llength $loadedmod_list] > 0}] } if {!$prereqloaded} { if {!$optional} { # error if requirement is not satisfied unless if optional reportMissingPrereqError $curmodnamevr {*}$args } } elseif {!$auto} { # apply missing tag to all loaded module found (already done when # dependency resolving is enabled) cmdModuleTag 0 0 $tag_list {*}$loadedmod_list } return {} } proc x-resource {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 $sepapos+1 end] set resource [string range $resource 0 $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 {[currentState mode] eq {load}} { set ::g_newXResources($resource) $value } else { set ::g_delXResources($resource) $value } return {} } proc uname {what} { return [switch -- $what { sysname {getState os} machine {getState machine} nodename - node {getState nodename} release {getState osversion} domain {getState domainname} version {getState kernelversion} default {knerror "uname $what not supported"} }] } # run shell command proc system {args} { # run through the appropriate shell if {[getState is_win]} { 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} { foreach coll $args { lassign [findCollections $coll exact] collfile colldesc if {[string length $collfile] > 0} { 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} { 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 {$abspath in $modpathlist} { 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} { # parse module version specification # a module name is mandatory set args [parseModuleSpecification 0 0 0 0 {*}$args] set ret 0 # disable error reporting to avoid modulefile errors # to pollute result. Only if not already inhibited set alreadyinhibit [getState inhibit_errreport] if {!$alreadyinhibit} { inhibitErrorReport } foreach mod $args { lassign [getPathToModule $mod] modfile modname modnamevr if {$modfile ne {}} { set ret 1 break } } # re-enable only is it was disabled from this procedure if {!$alreadyinhibit} { setState inhibit_errreport 0 } return $ret } proc execShAndGetEnv {shell script args} { set sep {%ModulesShToMod%} set subsep {%ModulesSubShToMod%} set shdesc [list $script {*}$args] set sherr 0 set shellopts [list] upvar ignvarlist ignvarlist set ignvarlist [list OLDPWD PWD _ _AST_FEATURES PS1 _LMFILES_\ LOADEDMODULES] # define shell command to run to source script and analyze the environment # changes it performs switch -- [file tail $shell] { dash - sh { # declare is not supported by dash but functions cannot be retrieved # anyway, so keep using declare and throw errors out to avoid overall # execution error. dash does not pass arguments to sourced script but # it does not raise error if arguments are set ##nagelfar ignore +3 Found constant set command "export -p; echo $sep; declare -f 2>/dev/null; echo\ $sep; alias; echo $sep; echo $sep; pwd; echo $sep; . [listTo\ shell $shdesc] 2>&1; echo $sep; export -p; echo $sep; declare -f\ 2>/dev/null; echo $sep; alias; echo $sep; echo $sep; pwd" set varre {export (\S+?)=["']?(.*?)["']?$} set funcre {(\S+?) \s?\n?{\s?\n(.+?)\n}$} set aliasre {(\S+?)='(.*?)'$} set varvalmap [list {\"} {"} \\\\ \\] set alvalmap [list {'\''} ' {'"'"'} '] } bash { ##nagelfar ignore +2 Found constant set command "export -p; echo $sep; declare -f; echo $sep; alias;\ echo $sep; complete; echo $sep; pwd; echo $sep; . [listTo shell\ $shdesc] 2>&1; echo $sep; export -p; echo $sep; declare -f; echo\ $sep; alias; echo $sep; complete; echo $sep; pwd" set varre {declare -x (\S+?)="(.*?)"$} set funcre {(\S+?) \s?\n{\s?\n(.+?)\n}$} set aliasre {alias (\S+?)='(.*?)'$} set compre {complete (.+?) (\S+?)$} set comprevar [list match value name] set varvalmap [list {\"} {"} \\\\ \\] set alvalmap [list {'\''} '] lappend shellopts --noprofile --norc } ksh - ksh93 { ##nagelfar ignore +3 Found constant set command "typeset -x; echo $sep; typeset +f | while read f; do\ typeset -f \${f%\$\$}; echo; done; echo $sep; alias; echo $sep;\ echo $sep; pwd; echo $sep; . [listTo shell $shdesc] 2>&1; echo\ $sep; typeset -x; echo $sep; typeset +f | while read f; do\ typeset -f \${f%\$\$}; echo; done; echo $sep; alias; echo $sep;\ echo $sep; pwd" set varre {(\S+?)=\$?'?(.*?)'?$} set funcre {(\S+?) {\n?(.+?)}[;\n]?$} set aliasre {(\S+?)=\$?'?(.*?)'?$} set varvalmap [list {\'} '] set alvalmap [list {\"} {"} {\\'} ' {\'} ' {\\\\} {\\}] } zsh { ##nagelfar ignore +2 Found constant set command "typeset -x; echo $sep; declare -f; echo $sep; alias;\ echo $sep; echo $sep; pwd; echo $sep; . [listTo shell $shdesc]\ 2>&1; echo $sep; typeset -x; echo $sep; declare -f; echo $sep;\ alias; echo $sep; echo $sep; pwd" set varre {(\S+?)=\$?'?(.*?)'?$} set funcre {(\S+?)  {\n(.+?)\n}$} set aliasre {(\S+?)=\$?'?(.*?)'?$} set varvalmap [list {'\''} '] set alvalmap [list {'\''} '] } csh { ##nagelfar ignore +2 Found constant set command "setenv; echo $sep; echo $sep; alias; echo $sep; echo\ $sep; pwd; echo $sep; source [listTo shell $shdesc] >&\ /dev/stdout; echo $sep; setenv; echo $sep; echo $sep; alias; echo\ $sep; echo $sep; pwd" set varre {(\S+?)=(.*?)$} set aliasre {(\S+?)\t(.*?)$} set varvalmap [list] set alvalmap [list] lappend shellopts -f } tcsh { ##nagelfar ignore +2 Found constant set command "setenv; echo $sep; echo $sep; alias; echo $sep;\ complete; echo $sep; pwd; echo $sep; source [listTo shell\ $shdesc] >& /dev/stdout; echo $sep; setenv; echo $sep; echo $sep;\ alias; echo $sep; complete; echo $sep; pwd" set varre {(\S+?)=(.*?)$} set aliasre {(\S+?)\t$?(.*?)$?$} set compre {(\S+?)\t(.*?)$} set comprevar [list match name value] set varvalmap [list] set alvalmap [list] lappend shellopts -f } fish { # exclude from search builtins, fish-specific functions and private # functions defined prior script evaluation: reduce this way the # the number of functions to parse. set getfunc "set funcout (string match -r -v \$funcfilter (functions\ -a -n) | while read f; functions \$f; echo '$subsep'; end)" ##nagelfar ignore +9 Found constant set command "set -xgL; echo '$sep'; status test-feature\ regex-easyesc 2>/dev/null; and set escrepl '\\\\\\\\\$1'; or set\ escrepl '\\\\\\\\\\\\\\\$1'; set funcfilter \\^\$(string\ join '|' (string replace -r '(\\\[|\\.)' \$escrepl\ (builtin -n; functions -a -n | string split ', ' | string match\ -e -r '^_')))\\|fish\\.\\*\$\\\$; $getfunc; $getfunc; string\ split \$funcout; echo '$sep'; string split \$funcout; echo\ '$sep'; complete; echo '$sep'; pwd; echo '$sep'; source [listTo\ shell $shdesc] 2>&1; or exit \$status; echo '$sep'; set -xgL;\ echo '$sep'; $getfunc; string split \$funcout; echo '$sep';\ string split \$funcout; echo '$sep'; complete; echo '$sep'; pwd" set varre {^(\S+?\M) ?'?(.*?)'?$} # exclude alias from function list set funcre "^function (\\S+?)(?: \[^\\n\]*?--description\ (?!'?alias)\[^\\n\]+)?\\n(.+?)?\\s*\\nend\\n$subsep\$" # fetch aliases from available functions set aliasre "^function (\\S+?) \[^\\n\]*?--description\ '?alias\[^\\n\]+\\n\\s*(.+?)(?: \\\$argv)?\\s*\\nend\\n$subsep\$" set compre {complete ((?:-\S+? )*?)(?:(?:-c|--command)\ )?([^-]\S+)(.*?)$} set comprevar [list match valpart1 name valpart2] # translate back fish-specific code set varvalmap [list {' '} : {\'} ' {\"} \" \\\\ \\] set alvalmap [list { $argv;} {}] # fish builtins change LS_COLORS variable lappend ignvarlist LS_COLORS } default { knerror "Shell '$shell' not supported" } } if {![file exists $script]} { knerror "Script '$script' cannot be found" } set shellpath [getCommandPath $shell] if {$shellpath eq {}} { knerror "Shell '$shell' cannot be found" } set shellexec [list $shellpath {*}$shellopts -c $command] reportDebug "running '$shellexec'" if {[catch {set output [exec {*}$shellexec]} output]} { set sherr 1 } # link result variables to calling context upvar cwdbefout cwdbefout cwdaftout cwdaftout # extract each output sections set idx 0 foreach varout {varbefout funcbefout aliasbefout compbefout cwdbefout\ scriptout varaftout funcaftout aliasaftout compaftout cwdaftout} { ##nagelfar vartype varout varName if {[set sepidx [string first $sep $output $idx]] == -1} { set $varout [string trimright [string range $output $idx end] \n] if {$varout ne {cwdaftout} && !$sherr} { knerror "Unexpected output when sourcing '$shdesc' in shell\ '$shell'" } } else { set $varout [string trimright [string range $output $idx $sepidx-1]\ \n] set idx [expr {$sepidx + [string length $sep] + 1}] } # remove expected Tcl error message if {$sherr && $varout eq {scriptout} && [set erridx [string\ last {child process exited abnormally} [set $varout]]] != -1} { set $varout [string range [set $varout] 0 $erridx-2] } } if {$sepidx != -1 && !$sherr} { knerror "Unexpected output when sourcing '$shdesc' in shell '$shell'" } reportDebug "script output is '$scriptout'" if {$sherr} { # throw error if script had an issue, send script output along if any set errmsg "Script '$script' exited abnormally" if {$scriptout ne {}} { append errmsg "\n with following output\n$scriptout" } knerror $errmsg } # link result variables to calling context upvar varbef varbef varaft varaft upvar funcbef funcbef funcaft funcaft upvar aliasbef aliasbef aliasaft aliasaft upvar compbef compbef compaft compaft # extract environment variable information ##nagelfar ignore Found constant foreach {out arr} [list varbefout varbef varaftout varaft] { ##nagelfar vartype out varName foreach {match name value} [regexp -all -inline -lineanchor $varre [set\ $out]] { # convert shell-specific escaping ##nagelfar ignore Suspicious variable name set ${arr}($name) [string map $varvalmap $value] } } # extract function information if function supported by shell if {[info exists funcre]} { ##nagelfar ignore Found constant foreach {out arr} [list funcbefout funcbef funcaftout funcaft] { foreach {match name value} [regexp -all -inline -lineanchor $funcre\ [set $out]] { # no specific escaping to convert for functions ##nagelfar ignore Suspicious variable name set ${arr}($name) $value } } } # extract alias information ##nagelfar ignore Found constant foreach {out arr} [list aliasbefout aliasbef aliasaftout aliasaft] { foreach {match name value} [regexp -all -inline -lineanchor $aliasre\ [set $out]] { ##nagelfar ignore Suspicious variable name set ${arr}($name) [string map $alvalmap $value] } } # extract complete information if supported by shell if {[info exists compre]} { ##nagelfar ignore Found constant foreach {out arr} [list compbefout compbef compaftout compaft] { ##nagelfar ignore Non constant variable list to foreach statement foreach $comprevar [regexp -all -inline -lineanchor $compre [set\ $out]] { if {[info exists valpart1]} { ##nagelfar ignore Unknown variable set value [concat $valpart1 $valpart2] } # no specific escaping to convert for completes ##nagelfar ignore Suspicious variable name lappend ${arr}($name) $value } } } } # execute script with args through shell and convert environment changes into # corresponding modulefile commands proc sh-to-mod {args} { set modcontent [list] set pathsep [getState path_separator] set shell [lindex $args 0] # evaluate script and retrieve environment before and after evaluation # procedure will set result variables in current context ##nagelfar implicitvarcmd {execShAndGetEnv *} ignvarlist cwdbefout\ cwdaftout varbef varaft funcbef funcaft aliasbef aliasaft compbef\ compaft execShAndGetEnv {*}$args # check environment variable change lassign [getDiffBetweenArray varbef varaft] notaft diff notbef foreach name $notaft { # also ignore Modules variables intended for internal use if {$name ni $ignvarlist && ![string equal -length 10 $name\ __MODULES_]} { lappend modcontent [list unsetenv $name] } } foreach name $diff { if {$name ni $ignvarlist && ![string equal -length 10 $name\ __MODULES_]} { # new value is totally different (also consider a bare ':' as a # totally different value to avoid erroneous matches) if {$varbef($name) eq $pathsep || [set idx [string first\ $varbef($name) $varaft($name)]] == -1} { lappend modcontent [list setenv $name $varaft($name)] } else { # content should be prepended if {$idx > 0} { set modcmd [list prepend-path] # check from the end to get the largest chunk to prepend set idx [string last $varbef($name) $varaft($name)] # get delimiter from char found between new and existing value set delim [string index $varaft($name) $idx-1] if {$delim ne $pathsep} { lappend modcmd -d $delim } lappend modcmd $name # split value and remove duplicate entries set vallist [list] appendNoDupToList vallist {*}[split [string range\ $varaft($name) 0 $idx-2] $delim] # an empty element is added if {[llength $vallist] == 0} { lappend vallist {} } lappend modcontent [list {*}$modcmd {*}$vallist] } # content should be appended if {($idx + [string length $varbef($name)]) < [string length\ $varaft($name)]} { set modcmd [list append-path] set delim [string index $varaft($name) $idx+[string length\ $varbef($name)]] if {$delim ne $pathsep} { lappend modcmd -d $delim } lappend modcmd $name set vallist [list] appendNoDupToList vallist {*}[split [string range\ $varaft($name) [expr {$idx + [string length $varbef($name)]\ + 1}] end] $delim] if {[llength $vallist] == 0} { lappend vallist {} } lappend modcontent [list {*}$modcmd {*}$vallist] } } } } foreach name $notbef { if {$name ni $ignvarlist && ![string equal -length 10 $name\ __MODULES_]} { if {[string first $pathsep $varaft($name)] == -1} { lappend modcontent [list setenv $name $varaft($name)] } else { # define a path-like variable if path separator found in it # split value and remove duplicate entries set vallist [list] appendNoDupToList vallist {*}[split $varaft($name) $pathsep] lappend modcontent [list prepend-path $name {*}$vallist] } } } # check function change lassign [getDiffBetweenArray funcbef funcaft] notaft diff notbef foreach name $notaft { lappend modcontent [list unset-function $name] } foreach name [list {*}$diff {*}$notbef] { lappend modcontent [list set-function $name \n$funcaft($name)] } # check alias change lassign [getDiffBetweenArray aliasbef aliasaft] notaft diff notbef foreach name $notaft { lappend modcontent [list unset-alias $name] } foreach name [list {*}$diff {*}$notbef] { lappend modcontent [list set-alias $name $aliasaft($name)] } # check complete change lassign [getDiffBetweenArray compbef compaft] notaft diff notbef foreach name $notaft { lappend modcontent [list uncomplete $name] } foreach name [list {*}$diff {*}$notbef] { foreach body $compaft($name) { lappend modcontent [list complete $shell $name $body] } } # check current working directory change if {$cwdbefout ne $cwdaftout} { lappend modcontent [list chdir $cwdaftout] } # sort result to ensure consistent output whatever the evaluation shell set modcontent [lsort -dictionary $modcontent] reportDebug "resulting env changes '$modcontent'" return $modcontent } proc source-sh {shell script args} { # evaluate script and get the environment changes it performs translated # into modulefile commands set shtomodargs [list $shell $script {*}$args] set modcontent [sh-to-mod {*}$shtomodargs] # register resulting modulefile commands setLoadedSourceSh [currentState modulename] [list $shtomodargs\ {*}$modcontent] # get name of current module Tcl interp set itrp [getCurrentModfileInterpName] # evaluate resulting modulefile commands through current Tcl interp foreach modcmd $modcontent { interp eval $itrp $modcmd } } # undo source-sh in unload mode proc source-sh-un {shell script args} { set shtomodargs [list $shell $script {*}$args] set modsrcsh [getLoadedSourceSh [currentState modulename]] # find commands resulting from source-sh evaluation recorded in env if {[set idx [lsearch -exact $modsrcsh $shtomodargs]] != -1 } { set modcontent [lindex $modsrcsh $idx+1] } else { set modcontent {} } # get name of current module unload Tcl interp set itrp [getCurrentModfileInterpName] # evaluate each recorded command in unload Tcl interp to get them reversed foreach modcmd $modcontent { interp eval $itrp $modcmd } } # report underlying modulefile cmds in display mode proc source-sh-di {shell script args} { set shtomodargs [list $shell $script {*}$args] # if module loaded, get as much content from environment as possible if {[is-loaded [currentState modulename]]} { set modsrcsh [getLoadedSourceSh [currentState modulename]] # find commands resulting from source-sh evaluation recorded in env if {[set idx [lsearch -exact $modsrcsh $shtomodargs]] != -1 } { set reccontent [lindex $modsrcsh $idx+1] } else { set reccontent {} } # need to evaluate script to get alias/function/complete definition execShAndGetEnv {*}$shtomodargs set modcontent {} foreach cmd $reccontent { # build modulefile content to show with recorded elements in env and # alias/function/complete definition obtained by reevaluating script switch -- [lindex $cmd 0] { complete { set cpname [lindex $cmd 2] if {[info exists compaft($cpname)]} { set cpbodylist $compaft($cpname) } else { set cpbodylist [list {}] } foreach cpbody $cpbodylist { lappend modcontent [list complete $shell $cpname $cpbody] } } set-alias { set alname [lindex $cmd 1] if {[info exists aliasaft($alname)]} { set albody $aliasaft($alname) } else { set albody {} } lappend modcontent [list set-alias $alname $albody] } set-function { set fnname [lindex $cmd 1] if {[info exists funcaft($fnname)]} { set fnbody \n$funcaft($fnname) } else { set fnbody {} } lappend modcontent [list set-function $fnname $fnbody] } default { lappend modcontent $cmd } } } # not loaded, so get full content from script evaluation } else { set modcontent [sh-to-mod {*}$shtomodargs] } # get name of current module unload Tcl interp set itrp [getCurrentModfileInterpName] # evaluate each recorded command in display Tcl interp to get them printed foreach modcmd $modcontent { interp eval $itrp $modcmd } } # parse arguments set on a variant modulefile command proc parseVariantCommandArgs {args} { set dflvalue {} set defdflvalue 0 set isboolean 0 set i 0 foreach arg $args { incr i if {[info exists nextargisval]} { ##nagelfar vartype nextargisval varName set $nextargisval $arg unset nextargisval } else { switch -glob -- $arg { --default { ##nagelfar ignore Found constant set nextargisval dflvalue set defdflvalue 1 } --boolean { set isboolean 1 } -* { knerror "Invalid option '$arg'" } default { set name $arg # end option parsing: remaining elts are allowed values break } } set prevarg $arg } } if {[info exists nextargisval]} { knerror "Missing value for '$prevarg' option" } # check variant name and allowed values if {![info exists name]} { knerror {No variant name specified} } if {![string match {[A-Za-z0-9_]} [string index $name 0]]} { knerror "Invalid variant name '$name'" } set values [lrange $args $i end] if {$isboolean} { if {[llength $values] > 0} { knerror "No value should be defined for boolean variant '$name'" } else { set values {1 0 yes no true false on off} } } else { foreach val $values { if {[string is boolean -strict $val] && ![string is integer\ -strict $val]} { knerror "Boolean value defined on non-boolean variant '$name'" } } } if {$defdflvalue && $isboolean} { # default value should be bool if variant is boolean if {![string is boolean -strict $dflvalue]} { knerror "Boolean value is expected as default value for variant\ '$name'" # translate default value in boolean canonical form (0 or 1) } else { set dflvalue [string is true -strict $dflvalue] } } return [list $name $values $defdflvalue $dflvalue $isboolean] } proc variant {itrp args} { # parse args lassign [parseVariantCommandArgs {*}$args] name values defdflvalue\ dflvalue isboolean # version variant is forbidden until specific implementation if {$name eq {version}} { knerror "'version' is a restricted variant name" MODULES_ERR_GLOBAL } # get variant list defined on command line set vrlist [getVariantListFromVersSpec [currentState modulenamevr]] # search for variant specification (most right-positionned value wins) for {set i [expr {[llength $vrlist]-1}]} {$i >= 0} {incr i -1} { lassign [lindex $vrlist $i] vrname vrvalue if {$vrname eq $name} { # translate value in boolean canonical form (0/1) if variant is bool if {$isboolean && [string is boolean -strict $vrvalue]} { set value [string is true -strict $vrvalue] } else { set value $vrvalue } set isdflval [expr {$defdflvalue && $dflvalue eq $value}] break } } # error if variant has not been specified unless a default is defined if {![info exists isdflval]} { if {$defdflvalue} { set value $dflvalue # 2 means default value automatically set set isdflval 2 # no error if variant is undefined on display mode, return here not to # set any variant-specific variable } elseif {[currentState mode] eq {display}} { return } else { set allowedmsg [expr {[llength $values] == 0 ? {} : "\nAllowed\ values are: $values"}] knerror "No value specified for variant '$name'$allowedmsg"\ MODULES_ERR_GLOBAL } } # check defined value if {($isboolean && ![string is boolean -strict $value]) || (!$isboolean &&\ [llength $values] > 0 && $value ni $values)} { # invalid value error is not a modulefile error knerror "Invalid value '$value' for variant '$name'\nAllowed values\ are: $values" MODULES_ERR_GLOBAL } else { # instantiate variant in modulefile context reportDebug "Set variant on $itrp: ModuleVariant($name) = '$value'" $itrp eval set "{::ModuleVariant($name)}" "{$value}" # after modfile interp ModuleVariant is unset by resetInterpState # record variant for persistency (name value is-boolean is-default) # unless module is currently unloading if {[currentState mode] ne {unload}} { setLoadedVariant [currentState modulename] [list $name $value\ $isboolean $isdflval] } } } # optimized variant command for whatis mode: init entry in ModuleVariant array # to avoid variable being undefined when accessed during modulefile evaluation proc variant-wh {itrp args} { # parse args lassign [parseVariantCommandArgs {*}$args] name values defdflvalue\ dflvalue isboolean # instantiate variant in modulefile context to an empty value reportDebug "Set variant on $itrp: ModuleVariant($name) = ''" $itrp eval set "{::ModuleVariant($name)}" "{}" } proc getvariant {itrp args} { # parse args lassign [parseGetenvCommandArgs getvariant {*}$args] name valifundef\ returnval if {[currentState mode] ne {display} || $returnval} { if {[$itrp eval info exists "{::ModuleVariant($name)}"]} { return [$itrp eval set "{::ModuleVariant($name)}"] } else { return $valifundef } } else { return [sgr va "{$name}"] } } proc require-fullname {} { # test specified name is any alternative name of currently evaluating mod # expect the default and parent dir name (which are considered unqualified) if {![modEq [currentState specifiedname] [currentState modulename] eqspec\ 1 4]} { knerror {Module version must be specified to load module}\ MODULES_ERR_GLOBAL } } proc prereqAllModfileCmd {tryload auto args} { lassign [parsePrereqCommandArgs prereq-all {*}$args] tag_list optional\ opt_list args # call prereq over each arg independently to emulate a prereq-all foreach arg $args { prereqAnyModfileCmd $tryload $auto {*}$opt_list $arg } } proc always-load {args} { lassign [parsePrereqCommandArgs always-load {*}$args] tag_list optional\ opt_list args # append keep-loaded tag to the list, second tag list in opt_list will take # over the initial list defined lappend tag_list keep-loaded lappend opt_list --tag [join $tag_list :] # auto load is inhibited if currently in DepRe context set auto [expr {[currentModuleEvalContext] eq {depre} ? {0} : {1}}] # load all module specified prereqAllModfileCmd 0 $auto {*}$opt_list {*}$args } proc family {name} { # ensure name is valid to be part of the name of an environment variable if {[string length $name] == 0 || ![regexp {^[A-Za-z0-9_]*$} $name]} { knerror "Invalid family name '$name'" } # only one loaded module could provide a given family conflict $name # set name as an alias for currently loading module setLoadedAltname [currentState modulename] al|$name # set variable in environment to know what module name provides family set upname [string toupper $name] lassign [getModuleNameVersion] mod modname modversion if {$modname eq {.}} { set modname [currentState modulename] } setenv MODULES_FAMILY_$upname $modname # also set Lmod-specific variable for compatibility setenv LMOD_FAMILY_$upname $modname } proc family-un {name} { # ensure name is valid to be part of the name of an environment variable if {[string length $name] == 0 || ![regexp {^[A-Za-z0-9_]*$} $name]} { knerror "Invalid family name '$name'" } # unset family-related environment variable set upname [string toupper $name] unsetenv MODULES_FAMILY_$upname unsetenv LMOD_FAMILY_$upname } proc complete {shell name body} { if {[string length $name] == 0} { knerror "Invalid command name '$name'" } # append definition retaining for which shell they are made # also some shells may set multiple definitions for a single name lappend ::g_Completes($name) $shell $body set ::g_stateCompletes($name) new # current module is qualified for refresh evaluation lappendState -nodup refresh_qualified [currentState modulename] } # undo complete in unload mode proc complete-un {shell name body} { return [uncomplete $name] } proc uncomplete {name} { if {[string length $name] == 0} { knerror "Invalid command name '$name'" } set ::g_Completes($name) {} set ::g_stateCompletes($name) del } proc pushenv {var val} { # save initial value in pushenv value stack set pushvar [getPushenvVarName $var] if {![info exists ::env($pushvar)] && [info exists ::env($var)]} { prepend-path $pushvar &$::env($var) } # 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 # add this value to the stack associated to current module name in order to # know what element to remove from stack when unloading prepend-path $pushvar [currentState modulename]&$val return {} } # undo pushenv in unload mode proc pushenv-un {var val} { # clean any existing reference counter array unset-env [getModshareVarName $var] 1 # update value stack set pushvar [getPushenvVarName $var] if {[info exists ::env($pushvar)]} { set pushlist [split $::env($pushvar) :] # find value pushed by currently evaluated module and remove it set popidx [lsearch -exact $pushlist [currentState modulename]&$val] if {$popidx != -1} { set pushlist [lreplace $pushlist $popidx $popidx] remove-path --index $pushvar $popidx } if {[llength $pushlist] > 0} { # fetch value on top of the stack set validx [expr {[string first & [lindex $pushlist 0]] + 1}] set popval [string range [lindex $pushlist 0] $validx end] # restore top value if different from current one # env array is used instead of get-env to know if envvar is undefined if {![info exists ::env($var)] || $::env($var) ne $popval} { set-env $var $popval } # if last element remaining in stack is the initial value prior first # pushenv, then clear the stack totally if {$validx == 1} { remove-path --index $pushvar 0 } } else { unset-env $var 0 $val } } else { # 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 pushenv for whatis mode (same approach than setenv-wh) proc pushenv-wh {var val} { if {![info exists ::env($var)]} { set ::env($var) {} } return {} } # optimized variant command for scan mode: init entry in ModuleVariant array # to avoid variable being undefined when accessed during modulefile evaluation # record variant definition in structure for extra match search or report proc variant-sc {itrp args} { # parse args lassign [parseVariantCommandArgs {*}$args] name values defdflvalue\ dflvalue isboolean # remove duplicate possible values for boolean variant if {$isboolean} { set values {on off} if {$defdflvalue} { set dflvalue [expr {$dflvalue ? {on} : {off}}] } } recordScanModuleElt [currentState modulename] $name variant lappend ::g_scanModuleVariant([currentState modulename]) [list $name\ $values $defdflvalue $dflvalue $isboolean] # instantiate variant in modulefile context to an empty value reportDebug "Set variant on $itrp: ModuleVariant($name) = ''" $itrp eval set "{::ModuleVariant($name)}" "{}" } proc setenv-sc {args} { lassign [parseSetenvCommandArgs load set {*}$args] bhv var val recordScanModuleElt [currentState modulename] $var setenv envvar if {![info exists ::env($var)]} { set ::env($var) {} } return {} } proc edit-path-sc {cmd args} { lassign [parsePathCommandArgs $cmd load noop {*}$args] separator allow_dup\ idx_val ign_refcount bhv var path_list recordScanModuleElt [currentState modulename] $var $cmd envvar if {![info exists ::env($var)]} { set ::env($var) {} } return {} } proc pushenv-sc {var val} { recordScanModuleElt [currentState modulename] $var pushenv envvar if {![info exists ::env($var)]} { set ::env($var) {} } return {} } proc unsetenv-sc {args} { lassign [parseUnsetenvCommandArgs load noop {*}$args] bhv var val recordScanModuleElt [currentState modulename] $var unsetenv envvar if {![info exists ::env($var)]} { set ::env($var) {} } return {} } proc complete-sc {shell name body} { if {[string length $name] == 0} { knerror "Invalid command name '$name'" } recordScanModuleElt [currentState modulename] $name complete } proc uncomplete-sc {name} { if {[string length $name] == 0} { knerror "Invalid command name '$name'" } recordScanModuleElt [currentState modulename] $name uncomplete } proc set-alias-sc {alias what} { recordScanModuleElt [currentState modulename] $alias set-alias } proc unset-alias-sc {alias} { recordScanModuleElt [currentState modulename] $alias unset-alias } proc set-function-sc {function what} { recordScanModuleElt [currentState modulename] $function set-function } proc unset-function-sc {function} { recordScanModuleElt [currentState modulename] $function unset-function } proc chdir-sc {dir} { recordScanModuleElt [currentState modulename] $dir chdir } proc family-sc {name} { if {[string length $name] == 0 || ![regexp {^[A-Za-z0-9_]*$} $name]} { knerror "Invalid family name '$name'" } recordScanModuleElt [currentState modulename] $name family } proc prereq-sc {args} { lassign [parsePrereqCommandArgs prereq {*}$args] tag_list optional\ opt_list args foreach modspec [parseModuleSpecification 0 0 0 0 {*}$args] { recordScanModuleElt [currentState modulename] $modspec prereq\ prereq-any require } } proc prereq-all-sc {args} { lassign [parsePrereqCommandArgs prereq-all {*}$args] tag_list optional\ opt_list args foreach modspec [parseModuleSpecification 0 0 0 0 {*}$args] { recordScanModuleElt [currentState modulename] $modspec prereq-all\ depends-on require } } proc always-load-sc {args} { lassign [parsePrereqCommandArgs always-load {*}$args] tag_list optional\ opt_list args foreach modspec [parseModuleSpecification 0 0 0 0 {*}$args] { recordScanModuleElt [currentState modulename] $modspec always-load\ require } } proc conflict-sc {args} { foreach modspec [parseModuleSpecification 0 0 0 0 {*}$args] { recordScanModuleElt [currentState modulename] $modspec conflict incompat } } proc module-sc {command args} { lassign [parseModuleCommandName $command help] command cmdvalid cmdempty # ignore sub-commands that do not either load or unload if {$command in {load load-any switch try-load unload}} { # parse options to distinguish them from module version spec lassign [parseModuleCommandArgs 0 $command 0 {*}$args] show_oneperline\ show_mtime show_filter search_filter search_match dump_state\ addpath_pos not_req tag_list args set modspeclist [parseModuleSpecification 0 0 0 0 {*}$args] if {$command eq {switch}} { # distinguish switched-off module spec from switched-on # ignore command without or with too much argument switch -- [llength $modspeclist] { {1} { # no switched-off module with one-arg form recordScanModuleElt [currentState modulename] $modspeclist\ switch switch-on require } {2} { lassign $modspeclist swoffarg swonarg recordScanModuleElt [currentState modulename] $swoffarg switch\ switch-off incompat recordScanModuleElt [currentState modulename] $swonarg switch\ switch-on require } } } else { set xtalias [expr {$command eq {unload} ? {incompat} : {require}}] # record each module spec foreach modspec $modspeclist { recordScanModuleElt [currentState modulename] $modspec $command\ $xtalias } } } } proc recordScanModuleElt {mod name args} { if {![info exists ::g_scanModuleElt]} { set ::g_scanModuleElt [dict create] } foreach elt $args { if {![dict exists $::g_scanModuleElt $elt]} { dict set ::g_scanModuleElt $elt {} } if {![dict exists $::g_scanModuleElt $elt $name]} { dict set ::g_scanModuleElt $elt $name [list $mod] } else { ##nagelfar ignore Suspicious variable name dict with ::g_scanModuleElt $elt {lappend $name $mod} } reportDebug "Module $mod defines $elt:$name" } } # test given variant specification matches what scanned module defines proc doesModVariantMatch {mod pvrlist} { set ret 1 if {[info exists ::g_scanModuleVariant($mod)]} { foreach availvr $::g_scanModuleVariant($mod) { set availvrarr([lindex $availvr 0]) [lindex $availvr 1] set availvrisbool([lindex $availvr 0]) [lindex $availvr 4] } foreach pvr $pvrlist { set pvrarr([lindex $pvr 0]) [lindex $pvr 1] set pvrisbool([lindex $pvr 0]) [lindex $pvr 2] } # no match if a specified variant is not found among module variants or # if the value is not available foreach vrname [array names pvrarr] { # if variant is a boolean, specified value should be a boolean too # any value accepted for free-value variant if {![info exists availvrarr($vrname)] || ($availvrisbool($vrname)\ && !$pvrisbool($vrname)) || (!$availvrisbool($vrname) && [llength\ $availvrarr($vrname)] > 0 && $pvrarr($vrname) ni\ $availvrarr($vrname))} { set ret 0 break } } } else { set ret 0 } return $ret } # collect list of modules matching all extra specifier criteria proc getModMatchingExtraSpec {pxtlist} { set res [list] if {[info exists ::g_scanModuleElt]} { foreach pxt $pxtlist { lassign $pxt elt name set one_crit_res [list] if {$elt in {require incompat load unload prereq conflict prereq-all\ prereq-any depends-on always-load load-any try-load switch\ switch-on switch-off}} { if {[dict exists $::g_scanModuleElt $elt]} { foreach modspec [dict get $::g_scanModuleElt $elt] { # modEq proc has been initialized in getModules phase #2 if {[modEq $modspec $name eqstart 1 5 1]} { # possible duplicate module entry in result list lappend one_crit_res {*}[dict get $::g_scanModuleElt\ $elt $modspec] } } } } else { # get modules matching one simple extra specifier criterion if {[dict exists $::g_scanModuleElt $elt $name]} { set one_crit_res [dict get $::g_scanModuleElt $elt $name] } } lappend all_crit_res $one_crit_res # no match on one criterion means no match globally, no need to test # further criteria if {[llength $one_crit_res] == 0} { break } } # matching modules are those found in every criteria result set res [getIntersectBetweenList {*}$all_crit_res] } return $res } # determine if current module search requires an extra match search proc isExtraMatchSearchRequired {mod} { # an extra match search is required if not currently inhibited and: # * variant should be reported in output # * mod specification contains variant during avail/paths/whatis # * mod specification contains extra specifier during avail/paths/whatis return [expr {![getState inhibit_ems 0] && ([isEltInReport variant 0] ||\ (([llength [getVariantListFromVersSpec $mod]] + [llength\ [getExtraListFromVersSpec $mod]]) > 0 && [currentState commandname] in\ {avail paths whatis}))}] } # perform extra match search on currently being built module search result proc filterExtraMatchSearch {mod res_arrname versmod_arrname} { # link to variables/arrays from upper context upvar $res_arrname found_list upvar $versmod_arrname versmod_list # get extra match query properties set spec_vr_list [getVariantListFromVersSpec $mod] set check_variant [expr {[llength $spec_vr_list] > 0}] set spec_xt_list [getExtraListFromVersSpec $mod] set check_extra [expr {[llength $spec_xt_list] > 0}] set filter_res [expr {$check_variant || $check_extra}] # disable error reporting to avoid modulefile errors (not coping with scan # evaluation for instance) to pollute result set alreadyinhibit [getState inhibit_errreport] if {!$alreadyinhibit} { inhibitErrorReport } set unset_list {} set keep_list {} # evaluate all modules found in scan mode to gather content information lappendState mode scan foreach elt [array names found_list] { switch -- [lindex $found_list($elt) 0] { modulefile - virtual { # skip evaluation of fully forbidden modulefile if {![isModuleTagged $elt forbidden 0]} { ##nagelfar ignore Suspicious variable name execute-modulefile [lindex $found_list($elt) 2] $elt $elt $elt\ 0 0 } } } # unset elements that do not match extra query if {$filter_res} { switch -- [lindex $found_list($elt) 0] { alias { # module alias does not hold properties to match extra query lappend unset_list $elt } modulefile - virtual { if {$check_variant && ![doesModVariantMatch $elt\ $spec_vr_list]} { lappend unset_list $elt } elseif {$check_extra} { # know currently retained modules to later compute those # to withdrawn lappend keep_list $elt } } } } } lpopState mode # get list of modules matching extra specifiers to determine those to not # matching that need to be withdrawn from result if {$check_extra} { set extra_keep_list [getModMatchingExtraSpec $spec_xt_list] lassign [getDiffBetweenList $keep_list $extra_keep_list]\ extra_unset_list set unset_list [list {*}$unset_list {*}$extra_unset_list] } # unset marked elements foreach elt $unset_list { unset found_list($elt) # also unset any symbolic version pointing to unset elt if {[info exists versmod_list($elt)]} { foreach eltsym $versmod_list($elt) { # getModules phase #2 may have already withdrawn symbol if {[info exists found_list($eltsym)]} { unset found_list($eltsym) } } } } # re-enable error report only is it was disabled from this procedure if {!$alreadyinhibit} { setState inhibit_errreport 0 } } # 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}] ##nagelfar vartype 0varname varName if {![info exists ${0varname}]} { set ${0varname} [get-env ${0varname}] } } # resolve 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 [currentState modulename] 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 {[currentState modulefile] 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)]} { lappend 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, exception 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 [list {*}$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 [list {*}$sym_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 [list\ {*}$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) [currentState modulefile] # record eventual missing resolution if {![info exists g_moduleResolved($modvers)]} { set g_moduleResolved($modvers) $modres reportDebug "$modvers resolved to $modres" lappend g_resolvedHash($modres) $modvers } } # 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_type 0} {modspec {}} {filter_default\ 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 } set modpar [file dirname $mod] set moddfl $modpar/default # add additionally 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 alternative name corresponds to one root name test if default # symbol is hidden set resmoddfl [expr {[lsearch -exact $resmodlist $resmod] != -1 ?\ "$resmod/default" : {}}] # if alternative name corresponds to default symbol and is hidden # test if query matches bare module name set resmodpar [expr {[file tail $resmod] eq {default} ? [file\ dirname $resmod] : {}}] # 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 modspec arg is set, exclude hidden entries not explicitly # matching modspec. auto symbols cannot be hidden # if filter_default is asked, skip parent module name and /default # symbol name from result list if {($modspec eq {} || ([info exists ::g_autoSymbol($resmod)] &&\ $::g_autoSymbol($resmod) eq $mod) || (![isModuleHidden $resmod\ $modspec] && ($resmoddfl eq {} || ![isModuleHidden $resmoddfl\ $modspec])) || [modEq $modspec $resmod eqspec] || ($resmodpar\ ne {} && [modEq $modspec $resmodpar eqspec])) && ([modEq\ $modelt $mod eqstart] || $::g_moduleResolved($resmod) eq $mod\ || $mod eq [lindex [getPathToModule\ $::g_moduleResolved($resmod) {} 0] 1]) && (!$filter_default ||\ (![modEq $resmod $modpar] && ![modEq $resmod $moddfl]))} { # prefix automatically generated syms with type flag if asked if {$flag_type && [info exists ::g_moduleAlias($resmod)]} { appendNoDupToList namelist al|$resmod } elseif {$flag_type && [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 } # build list for a given loaded module of its alternative names plus its # simplified names (name minus version or any subdir if this version or subdir # are the implicit default for module) proc getLoadedAltAndSimplifiedName {mod} { if {[isModuleFullPath $mod]} { set namelist [list $mod] # use already computed name list if any } elseif {[info exists ::g_loadedAltAndSimplifiedName($mod)]} { set namelist $::g_loadedAltAndSimplifiedName($mod) } else { # get recorded alternative name set namelist [getLoadedAltname $mod] # also look through modpaths for simplified mod name set modpathlist [getModulePathList] if {[llength $modpathlist] > 0} { set modfile [getModulefileFromLoadedModule $mod] set parentmod [file dirname $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} { lappend namelist $parentmod set parentmod [file dirname $parentmod] } else { set parentmod . } } } # recorded computed name list for later use set ::g_loadedAltAndSimplifiedName($mod) $namelist } return $namelist } # return value list of a loaded module property by parsing corresponding # environment variable proc getLoadedModulePropertyList {prop {filter_empty 1}} { switch -- $prop { name { set envvar LOADEDMODULES set subsplit 0 } file { set envvar _LMFILES_ set subsplit 0 } modulepath { set envvar MODULEPATH set subsplit 0 } default { set envvar __MODULES_LM[string toupper $prop] set subsplit [expr {$prop ni {init refresh}}] if {$prop in {altname conflict}} { set nosubsubsplit 1 } } } switch -- $prop { conflict - prereq - init { set unserialize_map {< :} } sourcesh { set unserialize_submap [list [getState path_separator]\ [getState sub1_separator]\ [getState sub2_separator]] } } set res_list [list] foreach elt [split [get-env $envvar] [getState path_separator]] { if {$subsplit} { set sub1sep [getState sub1_separator] set sub2sep [getState sub2_separator] # unserialize content of environment variable if map translation set if {[info exists unserialize_map]} { set elt [string map $unserialize_map $elt] } set subelt_list [split $elt $sub1sep] # ignore empty element (1 is meaningless as first elt is loaded mod) if {[llength $subelt_list] > 1 || !$filter_empty} { set subres_list {} foreach subelt $subelt_list { # keep first arg as string and other args as lists (unless if # subelt should not be split) if {[llength $subres_list] > 0 && ![info exists\ nosubsubsplit]} { set subelt [split $subelt $sub2sep] # skip empty value element if {[llength $subelt] == 0 && $filter_empty} { continue } } if {[info exists unserialize_submap]} { set subelt [string map $unserialize_submap $subelt] } lappend subres_list $subelt } lappend res_list $subres_list } } else { # ignore empty element if {$elt ne {} || !$filter_empty} { # unserialize content of env variable if map translation set if {[info exists unserialize_map]} { set elt [string map $unserialize_map $elt] } lappend res_list $elt } } } return $res_list } # 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 environment variable references in path elements # should be resolved or passed as-is in result list # set_abs param applies an absolute path name conversion to path elements # if enabled proc getModulePathList {{behavior returnempty} {resolv_var 1} {set_abs 1}} { if {![info exists ::env(MODULEPATH)] && $behavior eq {exiterronundef}} { reportErrorAndExit {No module path defined} } set modpath_list [list] foreach modpath [getLoadedModulePropertyList modulepath] { if {$resolv_var} { set modpath [resolvStringWithEnv $modpath] } if {$set_abs} { set modpath [getAbsolutePath $modpath] } appendNoDupToList modpath_list $modpath } return $modpath_list } # return list of the configured and existing global RC files proc getGlobalRcFileList {} { set rclist {} 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} } # ignore user rc if relative configuration is enabled if {![getConf ignore_user_rc] && [info exists ::env(HOME)] && [file isfile\ $::env(HOME)/.modulerc]} { lappend rclist $::env(HOME)/.modulerc } set readable_rclist {} foreach rc $rclist { if {[file readable $rc]} { lappend readable_rclist $rc } } return $readable_rclist } proc getModuleTag {mod tag {cmp eqstart} {return_rule 0}} { set modroot [getModuleRootFromVersSpec $mod] # look if mod matches one of the module specs applying to mod root if {[info exists ::g_moduleTagRoot($modroot)]} { set idx [lsearch -exact $::g_moduleTagRoot($modroot) $tag] if {$idx == -1} { return {} } else { foreach {tmodspec tprops} [lindex $::g_moduleTagRootSpec($modroot)\ $idx] { # first matching module spec wins with its properties if {[modEq $tmodspec $mod $cmp 1 0 1]} { if {$return_rule} { return $tmodspec } else { return [list $tag $tprops] } } } } } return {} } proc isModuleTagged {mod tag {collected 0}} { # retrieve tag information from collected tags or raw info if {$collected} { return [expr {$tag in [getTagList $mod]}] } else { return [expr {[llength [getModuleTag $mod $tag]] != 0}] } } proc getTaggedLoadedModuleList {tag} { set modlist [list] foreach mod [getLoadedModulePropertyList name] { if {[isModuleTagged $mod $tag 1]} { lappend modlist $mod } } return $modlist } proc getModuleTagProp {mod tag prop} { set ret {} array set tags [getModuleTag $mod $tag] if {[info exists tags($tag)]} { array set props $tags($tag) if {[info exists props($prop)]} { set ret $props($prop) } } return $ret } # Gather all tags applying to a given module proc collectModuleTags {mod} { set modroot [getModuleRootFromVersSpec $mod] # look if mod matches one of the module specs applying to mod root if {[info exists ::g_moduleTagRoot($modroot)]} { for {set i 0} {$i < [llength $::g_moduleTagRoot($modroot)]} {incr i} { set tag [lindex $::g_moduleTagRoot($modroot) $i] # skip already known tag if {![info exists ::g_tagHash($mod)] || $tag ni $::g_tagHash($mod)} { foreach {tmodspec tprops} [lindex\ $::g_moduleTagRootSpec($modroot) $i] { # add tag if one modspec matches mod if {[modEq $tmodspec $mod eqstart 1 0 1]} { setModuleTag $mod $tag break } } } } } } proc setModuleTag {mod args} { appendNoDupToList ::g_tagHash($mod) {*}$args } proc setModuleExtraTag {mod args} { appendNoDupToList ::g_extraTagHash($mod) {*}$args } proc unsetModuleTag {mod args} { if {[info exists ::g_tagHash($mod)]} { lassign [getDiffBetweenList $::g_tagHash($mod) $args] diff_list if {[llength $diff_list] > 0} { set ::g_tagHash($mod) $diff_list } else { unset ::g_tagHash($mod) } } } proc unsetModuleExtraTag {mod args} { if {[info exists ::g_extraTagHash($mod)]} { lassign [getDiffBetweenList $::g_extraTagHash($mod) $args] diff_list if {[llength $diff_list] > 0} { set ::g_extraTagHash($mod) $diff_list } else { unset ::g_extraTagHash($mod) } } } proc getTagList {mod {sort 1}} { if {[info exists ::g_tagHash($mod)]} { if {$sort} { set ret [lsort -dictionary $::g_tagHash($mod)] } else { set ret $::g_tagHash($mod) } reportDebug "'$mod' has tag list '$ret'" } else { set ret {} } return $ret } # return tags applying to mod that can be exported proc getExportTagList {mod {serialized 0}} { # remove loaded/hidden tags from the list to register lassign [getDiffBetweenList [getTagList $mod 0] [list loaded hidden]] ret if {$serialized && [llength $ret] > 0} { # extract mod name and version from full spec with variants set ret [join [list [getModuleNameAndVersFromVersSpec $mod] {*}$ret]\ [getState sub1_separator]] } return $ret } # return extra tags set on mod proc getExtraTagList {mod {serialized 0}} { if {[info exists ::g_extraTagHash($mod)]} { if {$serialized} { # extract mod name and version from full spec with variants set ret [join [list [getModuleNameAndVersFromVersSpec $mod]\ {*}$::g_extraTagHash($mod)] [getState sub1_separator]] } else { set ret $::g_extraTagHash($mod) } } else { set ret {} } return $ret } # return tags set on mod to record in collection proc getSaveTagList {mod} { # return all tags if pin tag is enabled, except nearly-forbidden that is # not intended for save if {[getConf collection_pin_tag]} { lassign [getDiffBetweenList [getExportTagList $mod] [list\ nearly-forbidden]] ret } else { set ret [getExtraTagList $mod] # in addition to those set with --tag option, add tags obtained by the # way mod has been loaded if {[isModuleTagged $mod auto-loaded 1]} { lappend ret auto-loaded } if {[isModuleTagged $mod keep-loaded 1]} { lappend ret keep-loaded } } return $ret } proc abbrevTagList {taglist} { set ret [list] foreach tag $taglist { if {[info exists ::g_tagAbbrev($tag)]} { # empty string abbrev means no tag report if {$::g_tagAbbrev($tag) ne {}} { lappend ret $::g_tagAbbrev($tag) } } else { lappend ret $tag } } return [lsort -dictionary $ret] } proc getVariantList {mod {report 0} {excl_dflval 0} {from 0}} { set vrspeclist {} set loadedsgrkey {} # fetch variant information from switch -- $from { 0 { # variant set after module being loaded if {[info exists ::g_loadedModuleVariant($mod)]} { set vrspeclist $::g_loadedModuleVariant($mod) } } 1 { # module specification set vrspeclist [getVariantListFromVersSpec $mod] } 2 { # variant definition collected during scan evaluation if {[info exists ::g_scanModuleVariant($mod)]} { set vrspeclist $::g_scanModuleVariant($mod) } # if module is currently loaded, gather its variant values if {[info exists ::g_loadedModuleVariant($mod)]} { foreach lovrspec $::g_loadedModuleVariant($mod) { lassign $lovrspec lovrname lovrvalue lovrvalisbool lovrvalisdfl if {$lovrvalisbool} { set lovrvalue [expr {$lovrvalue ? {on} : {off}}] } set lovrarr($lovrname) $lovrvalue } # get sgr key corresponding to loaded tag (if tag reported) if {$report == 7 && [isEltInReport tag]} { set loadedkind [expr {[isModuleTagged $mod auto-loaded 1] ?\ {auto-loaded} : {loaded}}] lassign [abbrevTagList [list $loadedkind]] loadedsgrkey } } } } # use array to make variant unique foreach vrspec $vrspeclist { if {$from == 2} { # report all available variant values on avail lassign $vrspec vrname vrvalues vrdefdflval vrdflval set vrvalisbool 0 set vrvalisdfl 0 # build value list to output for free-variant value if {[llength $vrvalues] == 0} { # if module is loaded, add loaded variant value if {[info exists lovrarr($vrname)]} { lappend vrvalues $lovrarr($vrname) } # if a default value is defined, add it to possible value list if {$vrdefdflval && $vrdflval ni $vrvalues} { lappend vrvalues $vrdflval } # indicate on free-value variant that all values are possible lappend vrvalues * } } else { lassign $vrspec vrname vrvalue vrvalisbool vrvalisdfl set vrvalues [list $vrvalue] } # correct is-default value if invalid if {![string is integer -strict $vrvalisdfl]} { set vrvalisdfl 0 } # correct is-boolean value if invalid if {![string is boolean -strict $vrvalisbool]} { set vrvalisbool 0 } set vrisbool($vrname) $vrvalisbool # correct boolean value if invalid if {$vrvalisbool && ![string is boolean -strict $vrvalue]} { set vrvalue 0 } # do not return variant if value is default, unless if variant was # specifically set to default value (isdfl=1) and we only want to # exclude the automatically set default value (excl_dflval=2) if {$excl_dflval > 0} { if {$vrvalisdfl == 0 || ($excl_dflval == 2 && $vrvalisdfl == 1)} { set vrarr($vrname) $vrvalue # nullify previous duplicate definition if this one is default } elseif {[info exists vrarr($vrname)]} { unset vrarr($vrname) } } else { if {$report == 7} { # indicate what value in the list is the default one if {[info exists vrdefdflval]} { set vrdflidxarr($vrname) [expr {$vrdefdflval ? [lsearch -exact\ $vrvalues $vrdflval] : {-1}}] } else { set vrdflidxarr($vrname) [expr {$vrvalisdfl ? {0} : {-1}}] } # indicate what value in the list is the loaded one set vrloidxarr($vrname) [expr {[info exists lovrarr($vrname)] ?\ [lsearch -exact $vrvalues $lovrarr($vrname)] : {-1}}] if {$vrvalisbool} { set vrarr($vrname) $vrvalue } else { set vrarr($vrname) $vrvalues } # is-default hint has to be transmitted on report mode '3' } elseif {$report == 3} { set vrarr($vrname) [list $vrvalue [expr {$vrvalisdfl > 0 &&\ $vrvalisdfl < 3}]] } else { set vrarr($vrname) $vrvalue } } } # sort variant to report set ret {} foreach vrname [lsort -dictionary [array names vrarr]] { switch -- $report { 4 {lappend ret $vrname $vrarr($vrname) $vrisbool($vrname)} 3 {lappend ret $vrname [lindex $vrarr($vrname) 0] [lindex\ $vrarr($vrname) 1]} 2 {lappend ret [list $vrname $vrarr($vrname) $vrisbool($vrname)]} 1 - 5 - 6 { if {$vrisbool($vrname)} { if {$vrarr($vrname)} { lappend ret +$vrname # track if +var variant has been reported to build key # unless if key should not be updated (report mode '6') if {$report != 6 && ![info exists ::g_used_va(on)]} { set ::g_used_va(on) 1 } } else { lappend ret -$vrname # track if -var variant has been reported to build key # unless if key should not be updated (report mode '6') if {$report != 6 && ![info exists ::g_used_va(off)]} { set ::g_used_va(off) 1 } } # use defined shortcut to report if any set for this variant # ignore shortcut if report=5 (when saving collection) } elseif {$report != 5 && [info exists\ ::g_variantShortcut($vrname)]} { set sc $::g_variantShortcut($vrname) lappend ret $sc$vrarr($vrname) # track if variant shortcut has been reported to build key # unless if key should not be updated (report mode '6') if {$report != 6 && ![info exists ::g_used_va($sc)]} { set ::g_used_va($sc) $vrname } } else { lappend ret $vrname=$vrarr($vrname) # track if var=val variant has been reported to build key # unless if key should not be updated (report mode '6') if {$report != 6 && ![info exists ::g_used_va(val)]} { set ::g_used_va(val) 1 } } } 7 { if {$vrisbool($vrname)} { if {$vrarr($vrname)} { lappend ret [list $vrname {} [list +$vrname]\ $vrdflidxarr($vrname) $vrloidxarr($vrname) $loadedsgrkey] # track if +var variant has been reported to build key if {![info exists ::g_used_va(on)]} { set ::g_used_va(on) 1 } } else { lappend ret [list $vrname {} [list -$vrname]\ $vrdflidxarr($vrname) $vrloidxarr($vrname) $loadedsgrkey] # track if -var variant has been reported to build key if {![info exists ::g_used_va(off)]} { set ::g_used_va(off) 1 } } # use defined shortcut to report if any set for this variant # ignore shortcut if report=5 (when saving collection) } elseif {$report != 5 && [info exists\ ::g_variantShortcut($vrname)]} { set sc $::g_variantShortcut($vrname) lappend ret [list $vrname $sc $vrarr($vrname)\ $vrdflidxarr($vrname) $vrloidxarr($vrname) $loadedsgrkey] # track if variant shortcut has been reported to build key # unless if key should not be updated (report mode '6') if {$report != 6 && ![info exists ::g_used_va($sc)]} { set ::g_used_va($sc) $vrname } } else { lappend ret [list $vrname $vrname= $vrarr($vrname)\ $vrdflidxarr($vrname) $vrloidxarr($vrname) $loadedsgrkey] # track if var=val variant has been reported to build key # unless if key should not be updated (report mode '6') if {$report != 6 && ![info exists ::g_used_va(val)]} { set ::g_used_va(val) 1 } } } 0 {lappend ret $vrname $vrarr($vrname)} } } return $ret } proc isModuleDotHidden {mod} { foreach elt [split $mod /] { if {[string index $elt 0] eq {.}} { return 1 } } return 0 } proc getModuleHidingLevel {mod} { set modroot [lindex [file split $mod] 0] # look if mod matches one of the hidden module specs applying to mod root if {[info exists ::g_moduleHideRoot($modroot)]} { for {set lvl 2} {$lvl > -1} {incr lvl -1} { foreach hmodspec [lindex $::g_moduleHideRoot($modroot) $lvl] { if {[modEq $hmodspec $mod eqstart 1 0 1 {}]} { return $lvl } } } } return -1 } proc setModspecHidingLevel {modspec lvl} { # skip record if an higher hiding level is already set if {![info exists ::g_moduleHide($modspec)] || $lvl >\ $::g_moduleHide($modspec)} { reportDebug "Record hidden module specification '$modspec' (lvl=$lvl)" set ::g_moduleHide($modspec) $lvl # record hidden mod spec for mod root to optimize search set modroot [getModuleRootFromVersSpec $modspec] if {![info exists ::g_moduleHideRoot($modroot)]} { set ::g_moduleHideRoot($modroot) [list [list] [list] [list]] } # record in list corresponding to hidden level to search from strongest # to weakest hidden level set hiderootlvllist [lindex $::g_moduleHideRoot($modroot) $lvl] lappend hiderootlvllist $modspec lset ::g_moduleHideRoot($modroot) $lvl $hiderootlvllist } } # test if mod is declared hidden or has one element in its name starting with # dot character. mod is considered hidden depending on their hiding level, # current search query and hiding threshold. when retdetails option is # enabled, mod hiding level and query match hind are also returned proc isModuleHidden {mod {modspec {}} {retdetails 0}} { set defhidlvl [set hidlvl [getModuleHidingLevel $mod]] if {$hidlvl >= [getState hiding_threshold]} { # soft hidden mods are considered matched if their root name matches # search query, other kind of hidden mods must fully matches query set hidmatch [expr {$hidlvl == 0 ? [modStartNb $mod $modspec] > 0 :\ [modEq $modspec $mod eqspec]}] } else { set hidlvl -1 set hidmatch 0 } if {$hidlvl < 1 && [set isdot [isModuleDotHidden $mod]] && [getState\ hiding_threshold] < 1} { set hidlvl 1 # dot hidden are considered matched if remaining string part after # search query is not dot hidden set hidmatch [expr {[set i [modStartNb $mod $modspec]] > 0 &&\ ![isModuleDotHidden [join [lrange [file split $mod] $i end] /]]}] } # hidden if hiding level greater or equal hiding threshold and not # matched or if matched hard hiding level are kept hidden set ishid [expr {$hidlvl != -1 && (!$hidmatch || $hidlvl > 1)}] # is module hidden by definition (whatever hiding threshold or match) set hidbydef [expr {$defhidlvl > 0 || ([info exists isdot] && $isdot)}] set ret [expr {$retdetails ? [list $hidlvl $hidmatch $hidbydef $ishid]\ : $ishid}] return $ret } # 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')" set vrlist [getVariantList $mod 1 0 1] if {$mod eq {}} { set retlist [list {} {} {} none [getEmptyNameMsg module]] # try first to look at loaded modules if enabled to find matching 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} } if {[set lm [$getLoadedNameProc $mod]] ne {}} { set vrlist [getVariantList $lm 1] set retlist [list [getModulefileFromLoadedModule $lm] $lm] } else { set retlist [list {} [getModuleNameAndVersFromVersSpec $mod]\ $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 $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] } set icase [isIcase] defineGetEqArrayKeyProc $icase [getConf extended_default] [getConf\ implicit_default] # Now search for $mod in module paths set modspec $mod foreach dir $dir_list { # get list of modules corresponding to searched query array unset mod_list array set mod_list [getModules $dir $mod 0 [list rc_defs_included\ resolve]] 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} { ##nagelfar ignore Found constant 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] if {[info exists mod_list($newmod)]} { set mod $newmod } else { # add specified variants to current resolution if {[llength $vrlist] > 0} { lassign [parseModuleSpecification 0 0 0 0 $newmod\ {*}$vrlist] newmod } # restart search on new modulename, constrained to # specified dir if set, if not found in current res 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 $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 an hidden dir if {![info exists mod_list($mod)] && [isModuleHidden\ $mod $modspec]} { # add specified variants to current resolution if {[llength $vrlist] > 0} { lassign [parseModuleSpecification 0 0 0 0 $mod\ {*}$vrlist] 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 [list {} $mod $mod {*}$mod_list($mod)] } } } } # break loop if found something (valid or invalid module) # elsewhere go to next path if {[info exists retlist]} { break } } } # set result if nothing found if {![info exists retlist]} { set retlist [list {} $mod $mod none "Unable to locate a modulefile for\ '$mod'"] } else { # build module name and variant with variant specified if {[llength $vrlist] > 0} { lassign [parseModuleSpecification 0 0 0 0 [lindex $retlist 1]\ {*}$vrlist] modnamevr } else { set modnamevr [lindex $retlist 1] } # update result if forbidden if {[isModuleTagged $modnamevr forbidden]} { set retlist [list {} [lindex $retlist 1] [lindex $retlist 2]\ accesserr [getForbiddenMsg $modnamevr]] } } if {[lindex $retlist 0] ne {}} { lappend retlist $modnamevr reportTrace "'[lindex $retlist 1]' ([lindex $retlist 0]) matching\ '$mod'" {Select module} # no error if we look at loaded modules and passed mod not found loaded } elseif {[lindex $retlist 3] ne {notloaded} && $report_issue} { reportIssue {*}[lrange $retlist 3 5] } 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 [expr {$mod in [getLoadingModuleList]}] } proc isModulefileLoading {modfile} { return [expr {$modfile in [getLoadingModuleFileList]}] } 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 isModuleRefreshQualified {mod} { return $::g_loadedModulesRefresh($mod) } proc setLoadedModule {mod modfile uasked modvr refresh} { 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 and relative loaded/auto-loaded tag set loadedtag [expr {$uasked ? {loaded} : {auto-loaded}}] setModuleTag $mod $loadedtag # also record tag for module designation including variants if specified if {$modvr ne {} && $mod ne $modvr} { setModuleTag $modvr $loadedtag } # is module qualified for refresh evaluation set ::g_loadedModulesRefresh($mod) $refresh # 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] } unset ::g_loadedModulesRefresh($mod) # update dependencies unsetModuleDependency $mod } # 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 1 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 ##nagelfar ignore Found constant foreach mod [getLoadedModulePropertyList name] { # 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 [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 [list getLoadingModuleList] } else { ##nagelfar ignore #3 Found constant set isModulefileLoaded isModulefileLoaded set getModuleFromLoadedModulefile getModuleFromLoadedModulefile set getLoadedModuleList [list getLoadedModulePropertyList name] } # 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] [expr {!$loading}] # 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 {[modEq $name $matchmod eqstart 1 [expr {$loading ? 1 : 2}] 1]} { 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 setLoadedSourceSh {mod args} { foreach arg $args { # each arg is a list with source-sh call string at index 0 and resulting # modulefile commands at all later index positions set shtomodargs [lindex $arg 0] set modcontent [lrange $arg 1 end] if {![info exists ::g_loadedModuleSourceSh($mod)] || $shtomodargs ni\ $::g_loadedModuleSourceSh($mod)} { # filter alias/function/complete definition not to record them set filtmodcont [list] foreach modcmdlist $modcontent { set modcmd [lindex $modcmdlist 0] switch -- $modcmd { set-alias - set-function { # set an empty body to make valid unset-* call lappend filtmodcont [list {*}[lrange $modcmdlist 0 1] {}] } complete { set complist [lrange $modcmdlist 0 2] # ensure only one order is recorded for each shell-name if {![info exists filtcomp($complist)]} { lappend filtmodcont [list {*}$complist {}] set filtcomp($complist) 1 } } default { lappend filtmodcont $modcmdlist } } } lappend ::g_loadedModuleSourceSh($mod) $shtomodargs $filtmodcont } } } proc unsetLoadedSourceSh {mod} { if {[info exists ::g_loadedModuleSourceSh($mod)]} { unset ::g_loadedModuleSourceSh($mod) } } proc getLoadedSourceSh {mod {serialized 0}} { set ret {} set pathsep [getState path_separator] set sub1sep [getState sub1_separator] set sub2sep [getState sub2_separator] set sermap [list $pathsep $sub1sep \ $sub2sep ] if {[info exists ::g_loadedModuleSourceSh($mod)]} { if {$serialized} { foreach {shtomodargs modcontent} $::g_loadedModuleSourceSh($mod) { # escape delimiter chars if used in content set shtomodargsser [string map $sermap $shtomodargs] set modcontentser [string map $sermap $modcontent] lappend modsrcsh $shtomodargsser$sub2sep[join $modcontentser\ $sub2sep] } set ret [join [list $mod {*}$modsrcsh] $sub1sep] } else { set ret $::g_loadedModuleSourceSh($mod) } } return $ret } proc setLoadedConflict {mod args} { 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 [list $mod\ {*}$::g_loadedModuleConflict($mod)] [getState 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] 1 # 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 {![modEq $withmod $mod eqstart 1 2 1] && (!$isfullpath ||\ ![modEq $withmod $smod eqstart 1 2 1]) && ([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 {$modcon ni $modconlist} { foreach withmod $::g_loadedModuleConflict($modcon) { # check if mod or one of its alt name match conflict if {[modEq $withmod $mod eqstart 1 2 1] || ($isfullpath &&\ [modEq $withmod $smod eqstart 1 2 1])} { 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} { 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 {} set sub2sep [getState sub2_separator] 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 $sub2sep] } # translate range specifier ':' into '<' to distinguish from path sep set ret [string map {: <} [join [list $mod {*}$modpre]\ [getState sub1_separator]]] } else { set ret $::g_loadedModulePrereq($mod) } } return $ret } proc setLoadedAltname {mod args} { foreach arg $args { switch -- [string range $arg 0 2] { al| { appendNoDupToList ::g_loadedModuleAliasAltname($mod) [string\ range $arg 3 end] } as| { appendNoDupToList ::g_loadedModuleAutoAltname($mod) [string range\ $arg 3 end] } default { appendNoDupToList ::g_loadedModuleAltname($mod) $arg } } } } proc unsetLoadedAltname {mod} { if {[info exists ::g_loadedModuleAltname($mod)]} { unset ::g_loadedModuleAltname($mod) } if {[info exists ::g_loadedModuleAliasAltname($mod)]} { unset ::g_loadedModuleAliasAltname($mod) } if {[info exists ::g_loadedModuleAutoAltname($mod)]} { unset ::g_loadedModuleAutoAltname($mod) } } proc getLoadedAltname {mod {serialized 0} {typelist {sym alias autosym}}} { set ret {} if {[info exists ::g_loadedModuleAltname($mod)] && {sym} in $typelist} { set ret $::g_loadedModuleAltname($mod) } if {[info exists ::g_loadedModuleAliasAltname($mod)] && {alias} in\ $typelist} { if {$serialized} { # add a 'al|' prefix to each alias to distinguish them when # serialized foreach altname $::g_loadedModuleAliasAltname($mod) { lappend ret al|$altname } } else { lappend ret {*}$::g_loadedModuleAliasAltname($mod) } } if {[info exists ::g_loadedModuleAutoAltname($mod)] && {autosym} in\ $typelist} { 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 { lappend 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 [list $mod {*}$ret] [getState sub1_separator]] } return $ret } proc setLoadedVariant {mod args} { lappend ::g_loadedModuleVariant($mod) {*}$args } proc unsetLoadedVariant {mod} { if {[info exists ::g_loadedModuleVariant($mod)]} { unset ::g_loadedModuleVariant($mod) } } proc getLoadedVariant {mod {serialized 0}} { set ret {} set sub2sep [getState sub2_separator] if {[info exists ::g_loadedModuleVariant($mod)]} { if {$serialized} { # get variant info as a string that can be registered in an env var foreach vrspec $::g_loadedModuleVariant($mod) { lappend modvrspec [join $vrspec $sub2sep] } # translate range specifier ':' into '<' to distinguish from path sep set ret [string map {: <} [join [list $mod {*}$modvrspec]\ [getState sub1_separator]]] } else { set ret $::g_loadedModuleVariant($mod) } } return $ret } proc getLoadedModuleWithVariantList {} { set modvrlist [list] foreach mod [getLoadedModulePropertyList name] { set modvr [list $mod] set vrlist [getVariantList $mod 5] if {[llength $vrlist] > 0} { lappend modvr {*}$vrlist } lappend modvrlist $modvr } return $modvrlist } proc getLoadedModuleWithVariantSaveTagArrayList {} { array set tag_arr {} foreach mod [getLoadedModulePropertyList name] { set modvr [list $mod] set vrlist [getVariantList $mod 1] if {[llength $vrlist] > 0} { lappend modvr {*}$vrlist } # create entry in array only if tags set set tag_list [getSaveTagList $mod] if {[llength $tag_list] > 0} { set tag_arr($modvr) $tag_list } } return [array get tag_arr] } # get current loaded state to record it as the virtual init collection proc getLoadedInit {} { set ret [formatCollectionContent [getModulePathList returnempty 0]\ [getLoadedModuleWithVariantList]\ [getLoadedModuleWithVariantSaveTagArrayList] {}] # remove ending newline in collection output set ret [string trimright $ret \n] # get init state as a string that can be registered in an env var translate # tag list separator ':' into '<' and line split '\n' into ':' set ret [string map {: < \n :} $ret] return $ret } # get all modules from all enabled modulepaths that matches a specification proc getAllAvailModule {mod} { array set mod_list {} # search is done from lowest to greatest priority path (if result array # content is kept later on, it will hold accurate priority information) foreach dir [lreverse [getModulePathList]] { array set mod_list [getModules $dir $mod 0 [list rc_defs_included]] } return [array names mod_list] } # 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 [getLoadedModulePropertyList name] defineModEqProc [isIcase] [getConf extended_default] 1 # 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 $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 {[modEq $modpre $lmmod eqstart 1 2 1]} { 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 {[modEq $modpre $lmmod eqstart 1 2 1]} { 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 {[modEq $modpre $mod eqstart 1 2 1]} { reportDebug "refresh requirements targeting '$modpre'" foreach lmmod $::g_unmetDepHash($modpre) { if {$mod in [getDependentLoadedModuleList [list $lmmod] 0 0]} { 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 consistently 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 targeting 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}] # 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}] # 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 targeting 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 ##nagelfar vartype reqVioVar varName 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 ##nagelfar ignore +2 Suspicious variable name 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 ##nagelfar ignore Suspicious variable name foreach lmmodlist [set ${reqListVar}($depmod)] { appendNoDupToList fulllist {*}$lmmodlist } } } return $ret } proc cacheCurrentModules {{exitonerr 1}} { # parse loaded modules information only once, global arrays are updated # afterwards when module commands update loaded modules state if {![isStateDefined lm_info_cached]} { setState lm_info_cached 1 # mark specific as well as generic modules as loaded set i 0 set modfilelist [getLoadedModulePropertyList file] set modlist [getLoadedModulePropertyList name] set refreshlist [getLoadedModulePropertyList refresh] if {[llength $modlist] == [llength $modfilelist]} { # cache declared variant of loaded modules foreach modvrspec [getLoadedModulePropertyList variant] { setLoadedVariant {*}$modvrspec # prepare modvr designation of loaded mod needed in next steps set mod [lindex $modvrspec 0] set vrlist [getVariantList $mod 6] set modvr [list $mod {*}$vrlist] set modvrarr($mod) $modvr } # cache declared tags of loaded modules foreach modtag [getLoadedModulePropertyList tag] { setModuleTag {*}$modtag # also record tag over full mod and vr designation set mod [lindex $modtag 0] if {[info exists modvrarr($mod)]} { setModuleTag $modvrarr($mod) {*}[lrange $modtag 1 end] } } foreach modtag [getLoadedModulePropertyList extratag] { setModuleExtraTag {*}$modtag # also record tag over full mod and vr designation set mod [lindex $modtag 0] if {[info exists modvrarr($mod)]} { setModuleExtraTag $modvrarr($mod) {*}[lrange $modtag 1 end] } } # cache declared alternative names of loaded modules foreach modalt [getLoadedModulePropertyList altname] { setLoadedAltname {*}$modalt } # cache declared source-sh of loaded modules foreach modsrcsh [getLoadedModulePropertyList sourcesh] { setLoadedSourceSh {*}$modsrcsh } # cache declared conflict of loaded modules foreach modcon [getLoadedModulePropertyList conflict] { # parse module version specification to record translation foreach modconelt [lrange $modcon 1 end] { parseModuleSpecification 0 0 0 0 {*}$modconelt } setLoadedConflict {*}$modcon } # cache declared prereq of loaded modules, prior to setLoadedModule # which triggers dependency chain build foreach modpre [getLoadedModulePropertyList prereq] { # parse module version specification to record translation foreach modpreeltlist [lrange $modpre 1 end] { foreach modpreelt $modpreeltlist { parseModuleSpecification 0 0 0 0 {*}$modpreelt } } setLoadedPrereq {*}$modpre } foreach mod $modlist { # get all tags also recorded on mod and vr designation if {[info exists modvrarr($mod)]} { set modvr $modvrarr($mod) } else { set modvr {} } setLoadedModule $mod [lindex $modfilelist $i] [expr\ {![isModuleTagged $mod auto-loaded 1]}] $modvr [expr {$mod in\ $refreshlist}] incr i } reportDebug "$i loaded" } else { set errproc [expr {$exitonerr ? {reportErrorAndExit} :\ {reportError}}] $errproc "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 } reportTrace "'$name' into '$ret'" Resolve return $ret } 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} { # test file only once, cache result obtained to minimize file query # consider modfile valid without reading it if mcookie_check < always return [expr {[info exists ::g_modfileValid($modfile)]\ ? $::g_modfileValid($modfile)\ : [set ::g_modfileValid($modfile) [expr {[getConf mcookie_check] eq\ {always} ? [readModuleContent $modfile 1 1] : [list true {}]}]]}] } # 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 { # protect 'file mtime' call in case we do not know what we are checking # when mcookie is not checked if {[catch { set mtime [file mtime $fpath] } errMsg ]} { reportError [parseAccessIssue $fpath] set mtime {} } return [set ::g_fileMtime($fpath) $mtime] } } # 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} {must_have_cookie 0}} { set fid [open $filename r] if {$firstline} { set fdata [gets $fid] } else { # read a first data chunk and check if magic cookie is there if # mandatory. skip read of any additional content if mandatory cookie is # not found set fdata [read $fid 4096] if {![eof $fid] && (!$must_have_cookie || [string equal -length 8\ $fdata {#%Module}])} { append fdata [read $fid] } } close $fid return $fdata } proc readModuleContent {modfile {report_read_issue 0} {only_check_validity\ 0}} { 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. when full file should be read # cookie is checked if asked to avoid to fully read non modfile set fdata [readFile $modfile [expr {$only_check_validity &&\ ![currentState always_read_full_file]}] 1] # 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 || [currentState always_read_full_file]} { 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 {![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 } elseif {[string length $fh] > 8 && [getConf mcookie_version_check] &&\ [versioncmp {5.3.0} [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} { set sym_list {} if {[info exists ::g_symbolHash($mod)]} { set sym_list $::g_symbolHash($mod) # withdraw hidden symbol from list if {[info exists ::g_hiddenSymHash($mod)]} { lassign [getDiffBetweenList $sym_list $::g_hiddenSymHash($mod)]\ sym_list } } reportDebug "'$mod' has symbolic version list '$sym_list'" return $sym_list } proc doesModuleHaveSym {mod} { # is there any non-hidden symbol for mod return [expr {[info exists ::g_symbolHash($mod)] && (![info exists\ ::g_hiddenSymHash($mod)] || [llength [lindex [getDiffBetweenList\ $::g_symbolHash($mod) $::g_hiddenSymHash($mod)] 0]] > 0)}] } # 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_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_dotversion} { set dir_list [list] set elt_list [glob -nocomplain $dir/*] # Add each element in the current directory to the list foreach elt $elt_list { lappend dir_list $elt 0 } # search for hidden files foreach elt [glob -nocomplain -types hidden -directory $dir -tails *] { switch -- $elt { . - .. { } .modulerc - .version { if {($fetch_dotversion || $elt ne {.version}) && [file readable\ $dir/$elt]} { lappend dir_list $dir/$elt 0 } } default { lappend dir_list $dir/$elt 1 } } } return $dir_list } # 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] } # Walk through provided list of directories and files to find modules proc findModulesFromDirsAndFiles {dir full_list depthlvl fetch_mtime\ res_arrname {indir_arrname {}} {hidden_listname {}} {fknown_arrname {}}\ {dknown_arrname {}}} { # link to variables/arrays from upper context upvar $res_arrname mod_list if {$indir_arrname ne {}} { upvar $indir_arrname modfile_indir } if {$hidden_listname ne {}} { upvar $hidden_listname hidden_list } if {$fknown_arrname ne {}} { upvar $fknown_arrname fknown_arr } if {$dknown_arrname ne {}} { upvar $dknown_arrname dknown_arr } 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 tail [file tail $element] set modulename [getModuleNameFromModulepath $element $dir] set parentname [file dirname $modulename] set moddepthlvl [llength [file split $modulename]] # check if element is a directory if we do not already know if it is a # dir or a file from transmitted structures if {[info exists dknown_arr($modulename)] || (![info exists\ fknown_arr($modulename)] && [file isdirectory $element])} { if {![info exists ignored_dirs($tail)]} { if {[catch { set elt_list [getFilesInDirectory $element 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] } } .modulecache - *~ - *,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 {![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] } } } } } } } } # finds all module-related files matching mod in the module path dir proc findModules {dir mod depthlvl fetch_mtime} { reportDebug "finding '$mod' in $dir (depthlvl=$depthlvl,\ fetch_mtime=$fetch_mtime)" # generated search id (for cache search/save) by compacting given args set searchid $dir:$mod:$depthlvl:$fetch_mtime # 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 } # look at modulepath cache file lassign [findModulesInCacheFile $dir $mod $depthlvl $fetch_mtime] cache_ok\ cache_list if {$cache_ok} { # record cache file findinds in memory cache reportDebug "create cache entry '$searchid'" set ::g_foundModulesMemCache($searchid) $cache_list return $cache_list } defineModEqStaticProc [isIcase] [getConf extended_default] $mod # every entries are requested set findall [expr {$mod eq {} || $mod eq {*}}] # use catch protection to handle non-readable and non-existent dir if {[catch { set full_list {} foreach {fpelt hid} [getFilesInDirectory $dir 0] { set elt [file tail $fpelt] # include any .modulerc file found at the modulepath root if {$elt eq {.modulerc} || $findall || [modEqStatic $elt match]} { lappend full_list $fpelt } } }]} { return {} } # walk through list of dirs and files to find modules findModulesFromDirsAndFiles $dir $full_list $depthlvl $fetch_mtime mod_list 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 {}} {filter {}}} { global g_sourceAlias g_sourceVersion g_sourceVirtual g_rcAlias\ g_moduleAlias g_rcVersion g_moduleVersion g_rcVirtual g_moduleVirtual\ g_rcfilesSourced reportDebug "get '$mod' in $dir (fetch_mtime=$fetch_mtime, search=$search,\ filter=$filter)" # generated search id (for cache search/save) by compacting given args set searchid $dir:$mod:$fetch_mtime:$search:$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 {{noindepth} ni $search}] # set a default if none defined on directory entries set implicitdfl [getConf implicit_default] # automatically define latest and default sym for all modules # disable when implicit default or advanced version spec are disabled or # if search query does not contain a module name and version but variant set autosymbol [expr {$implicitdfl && [getConf advanced_version_spec] &&\ ![isSpecWildWithVariant $mod]}] # match passed name against any part of avail module names set contains [expr {{contains} in $search}] set mtest [expr {$contains ? {matchin} : {match}}] set icase [isIcase] set wild [expr {{wild} in $search}] # 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 trimright $querydir /] set querydepth [countChar $modqe /] # get directory relative to module name set moddir [getModuleNameFromVersSpec $mod] set hasmoddir [expr {$moddir ne {.}}] set modroot [getModuleRootFromVersSpec $mod] set earlyfilter [expr {!$contains && !$wild && $modroot eq [string\ map {* {} ? {}} $modroot]}] # are result entries gathered in a resolution context ? set resctx [expr {{resolve} in $search}] # need to perform an extra match search? set ems_required [isExtraMatchSearchRequired $mod] # if search for global or user rc alias only, no dir lookup is performed # and aliases from g_rcAlias are returned if {{rc_alias_only} in $search} { set add_rc_defs 1 array set found_list {} } else { # find modules by searching mod root name in order to catch all module # related entries to correctly computed auto symbols afterward if {$contains} { set findmod * } else { set findmod $modroot # if searched mod is an empty or flat element append wildcard # character to match anything starting with mod if {$wild && !$hasmoddir && [string index $findmod end] ne {*}} { append findmod * } } # add alias/version definitions from global or user rc to result set add_rc_defs [expr {{rc_defs_included} in $search}] # if no indepth mode search, pass the depth level of the search query # unless EMS need to be performed (findModules should fetch everything) set depthlvl [expr {$indepth || [isExtraMatchSearchRequired $mod] ? 0 :\ $querydepth + 1}] array set found_list [findModules $dir $findmod $depthlvl $fetch_mtime] } # Phase #1: consolidate every kind of entries (directory, modulefile, # symbolic version, alias and virtual module) in found_list array set err_list {} array set versmod_list {} 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 or in global or user rc definitions foreach vers [array names g_moduleVersion] { set versmod $g_moduleVersion($vers) if {($dir ne {} && [string first $dir/ $g_sourceVersion($vers)] == 0)\ || [info exists g_rcVersion($vers)]} { set found_list($vers) [list version $versmod] # build module symbol list lappend versmod_list($versmod) $vers # add global/user rc def to module symbol list in any cases } elseif {!$add_rc_defs && [info exists g_rcVersion($vers)]} { lappend versmod_list($versmod) $vers } } # 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)])} { ##nagelfar ignore Found constant 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 # define module name and version comparison procs defineModStartNbProc $icase defineModEqProc $icase [getConf extended_default] defineModEqStaticProc $icase [getConf extended_default] $mod # remove hidden elements unless they are (or their symbols) targeted by # search query. foreach elt [array names found_list] { if {$earlyfilter && ![modEq $modroot $elt eqstart]} { unset found_list($elt) continue } if {[lassign [isModuleHidden $elt $mod 1] hidlvl hidmatch hidbydef]} { # is there a symbol that matches query (bare module name query # matches default symbol on resolve context or if onlydefaults filter # is applied) if {!$hidmatch && [info exists versmod_list($elt)]} { foreach eltsym $versmod_list($elt) { if {[modEqStatic $eltsym] || (($resctx || $filter eq\ {onlydefaults}) && "$mod/default" eq $eltsym)} { set hidmatch 1 break } } } # consider 'default' symbols are explicitly specified if # onlydefaults filter applied or resolving bare module name if {!$hidmatch && [lindex $found_list($elt) 0] eq {version} && [file\ tail $elt] eq {default} && ($filter eq {onlydefaults} || ($resctx\ && "$mod/default" eq $elt))} { set hidmatch 1 } # not hidden if matched unless if hard hiding apply if {!$hidmatch || $hidlvl > 1} { # record hidden symbol, not to display it in listModules if {[lindex $found_list($elt) 0] eq {version}} { lappend ::g_hiddenSymHash([lindex $found_list($elt) 1]) [file\ tail $elt] } # transform forbidden module in error entry if it specifically # matches search query if {$hidlvl == 2 && $hidmatch && [isModuleTagged $elt\ forbidden]} { set found_list($elt) [list accesserr [getForbiddenMsg $elt]] set err_list($elt) 1 } else { unset found_list($elt) } } } # apply hidden tag if an hidden definition apply to module if {$hidbydef} { setModuleTag $elt hidden } } # Phase #3: elaborate directory content with default element selection array set dir_list {} array set autosym_list {} # build list of elements contained in each directory foreach elt [array names found_list] { # add a ref to element in its parent directory unless element has error # or is a symbolic version then recursively add parent element until # reaching top directory if {![info exists err_list($elt)] && [lindex $found_list($elt) 0] ne\ {version}} { 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 # but override alias entry if extra match search is required (as it # withdrawn module aliases) foreach elt [array names dir_list] { if {![info exists found_list($elt)] || ($ems_required && [lindex\ $found_list($elt) 0] eq {alias})} { set dir_list($elt) [lsort -dictionary $dir_list($elt)] # get default element: explicitly defined default (whether it exists # or is in error) or implicit default if enabled if {[info exists found_list($elt/default)] && [lindex\ $found_list($elt/default) 0] eq {version}} { set dfl [file tail [lindex $found_list($elt/default) 1]] } elseif {$implicitdfl} { set dfl [lindex $dir_list($elt) end] } else { set dfl {} } # record directory properties set found_list($elt) [list directory $dfl {*}$dir_list($elt)] # automatically define symbols for all modules matching query if # these names do not exist yet or if in error, in which case only # auto symbol resolution is set if {$autosymbol && (!$hasmoddir || [modEq $modroot $elt eqstart])} { if {![info exists found_list($elt/default)] || [info exists\ err_list($elt/default)]} { if {![info exists found_list($elt/default)]} { set found_list($elt/default) [list version $elt/$dfl] lappend versmod_list($elt/$dfl) $elt/default set autosym_list($elt/default) 1 } setModuleResolution $elt/default $elt/$dfl default 1 1 } if {![info exists found_list($elt/latest)] || [info exists\ err_list($elt/latest)]} { set lat [lindex $dir_list($elt) end] if {![info exists found_list($elt/latest)]} { set found_list($elt/latest) [list version $elt/$lat] lappend versmod_list($elt/$lat) $elt/latest set autosym_list($elt/latest) 1 } setModuleResolution $elt/latest $elt/$lat latest 1 1 } } } } # Phase #4: perform extra match search if {$ems_required} { filterExtraMatchSearch $mod found_list versmod_list } # ensure modEqStatic is defined as expected (could have been redefined # during scan evaluation) defineModEqStaticProc $icase [getConf extended_default] $mod # Phase #5: filter results to keep those matching search query # define module name and version comparison procs defineDoesModMatchAtDepthProc $indepth $querydepth $mtest # element to include in output set report_dirwsym [isEltInReport dirwsym] array set mod_list {} array set fdir_list {} array set keep_list {} # keep element matching query, add directory of element matching query, # also add directory to result if query name finishes with trailing slash; # only keep auto syms if fully matched or version not specified in query; # (hidden elements have been filtered on phase 2) 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] || ($hasmoddir &&\ $elt_type eq {directory} && [modEq $moddir $elt]))) || ($isquerydir\ && $elt_type eq {directory} && [modEq $querydir $elt match 0])) &&\ (![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}} { # resolve eventual icase target set versmod [getArrayKey found_list [lindex $mod_list($elt) 1]\ $icase] # 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 if # hidden but should not be in error set pardir [file dirname $tgt] if {([info exists found_list($tgt)] || ($pardir ne {.} &&\ ![info exists found_list($pardir)] && [isModuleHidden\ $tgt $mod])) && ![info exists err_list($tgt)]} { # create parent directory if it does not exist if {$pardir ne {.} && ![info exists\ found_list($pardir)]} { set found_list($pardir) [list directory] set mod_list($pardir) [list directory] } 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 } elseif {[info exists err_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: explicitly defined default if included in # result or not found or implicit default if enabled if {[info exists found_list($elt/default)] && [lindex\ $found_list($elt/default) 0] eq {version} && ([info exists\ mod_list([set versmod [lindex $found_list($elt/default) 1]])] ||\ ![info exists found_list($versmod)])} { set dfl [file tail $versmod] } 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) [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 syms when indepth # enabled or if corresponds to query depth when indepth disabled } elseif {$filtering && $filter eq {noplaindir} &&\ (($indepth && (!$report_dirwsym || ![doesModuleHaveSym $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) } } } # Phase #6: consolidate tags set for retained modules if {[currentState commandname] eq {avail}} { # load tags from loaded modules in the global structure prior collecting # tags found during this getModules evaluation cacheCurrentModules 0 foreach elt [array names mod_list] { switch -- [lindex $mod_list($elt) 0] { alias - modulefile - virtual { # gather all tags applying to elt collectModuleTags $elt } } } } reportTrace "{[array names mod_list]} matching '$mod' in '$dir'" {Get\ modules} # cache search results reportDebug "create cache entry '$searchid'" set got_list [array get mod_list] set ::g_gotModulesMemCache($searchid) $got_list return $got_list } # gather for the current top evaluation the information on all evaluations # happening under its umbrella proc registerModuleEval {context msgrecid {failedmod {}} {failedcontext {}}} { set evalid [topState evalid] set unset [expr {$failedmod eq {} ? 0 : 1}] set contextset 0 # add msgrecid 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\ $msgrecid] } else { lappend contextevallist $msgrecid } 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 msgrecid to new evaluation context list if {!$unset && !$contextset} { lappend ::g_moduleEval($evalid) [list $context $msgrecid] } # add mod to failed evaluation list if {$unset} { lappend ::g_moduleFailedEval($evalid) $failedcontext $failedmod } } # record that module evaluation is set hidden proc registerModuleEvalHidden {context msgrecid} { set evalid [topState evalid] lappend ::g_moduleHiddenEval($evalid:$context) $msgrecid } # get context of currently evaluated module proc currentModuleEvalContext {} { return [lindex $::g_moduleEvalAttempt([currentState modulenamevr]) 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 # 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 (translate # eventual modspec in evalmod into module names, in case module # evaluation stopped prior module name setup) # retrieve variants to pass them directly to modEq set modvrlist [getVariantList $evalmod 0 0 1] foreach mod [getAllModulesFromVersSpec $evalmod] { foreach name $args { # indicate module is loading to also compare against all alt names if {[modEq $name $mod eqstart 1 1 1 $modvrlist]} { set evalmatch 1 if {$context eq {any} || $context in\ $::g_moduleEvalAttempt($evalmod)} { 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 [topState evalid] 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 } # return list of currently loading modules in stack proc getLoadingModuleList {} { set modlist [list] for {set i 0} {$i < [depthState modulename]} {incr i 1} { if {[lindex [getState mode] $i] eq {load}} { lappend modlist [lindex [getState modulename] $i] } } return $modlist } # return list of currently loading modulefiles in stack proc getLoadingModuleFileList {} { set modlist [list] for {set i 0} {$i < [depthState modulefile]} {incr i 1} { if {[lindex [getState mode] $i] eq {load}} { lappend modlist [lindex [getState modulefile] $i] } } return $modlist } # return list of currently unloading modules in stack proc getUnloadingModuleList {} { set modlist [list] for {set i 0} {$i < [depthState modulename]} {incr i 1} { if {[lindex [getState mode] $i] eq {unload}} { lappend modlist [lindex [getState modulename] $i] } } return $modlist } # 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 [getLoadedModulePropertyList name] { if {$lmmod in $modlist} { lappend sortlist $lmmod } } # also sort eventual loading modules if asked if {$loading} { foreach loadingmod [lreverse [getLoadingModuleList]] { if {$loadingmod in $modlist} { 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 ##nagelfar ignore #4 Suspicious variable name if {[info exists ${reqListVar}($mod)]} { # goes over all dependent 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 loaded modules having an unmet requirement on passed mod # and their recursive dependent proc getUnmetDependentLoadedModuleList {modnamevr} { set unmetdeplist {} set depmodlist {} defineModEqProc [isIcase] [getConf extended_default] 1 set mod [getModuleNameAndVersFromVersSpec $modnamevr] set vrlist [getVariantList $modnamevr 0 0 1] # 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 {[modEq $ummod $mod eqstart 1 2 1 $vrlist]} { 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 {[modEq $modpre $mod eqstart 1 2 1 $vrlist] ||\ [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 [list {*}$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 } ##nagelfar ignore #2 Suspicious variable name 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} { ##nagelfar ignore Suspicious variable name foreach lmmodlist [set ${reqListVar}([lindex $depmod 0])] { if {$mod in $lmmodlist} { foreach lmmod $lmmodlist { # other mod part of the opt list is not there so mod # is considered optional if {$lmmod ni $othmodlist} { set add 0 break } } break } } } if {$add} { lappend deplist [lindex $depmod 0] } } } # take currently loading modules into account if asked if {$loading} { set modlist [getLoadedModulePropertyList name] defineModEqProc [isIcase] [getConf extended_default] 1 # 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 {[modEq $modpre $lmmod eqstart 1 2 1]} { 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 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 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} { appendNoDupToList fulllist {*}[getDirectDependentList $depmod\ $strong $nporeq 0 $fulllist] } # avoid module currently unloading from result list if {$depmod ni $unloadingmodlist} { 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] } # loaded tag means module was not auto-loaded. keep-loaded means module is # not auto-unloadable even if auto-loaded if {[isModuleTagged $mod loaded 1] || [isModuleTagged $mod keep-loaded\ 1]} { set ret 0 } else { # mod is unloadable if all its dependent are unloaded or unloading foreach depmod [getDirectDependentList $mod] { if {$depmod ni $unmodlist} { 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} { # 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 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} { # 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 {$lmmod ni $fulllist} { 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 } # 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_stateCompletes g_Completes\ g_newXResources g_delXResources g_loadedModules g_loadedModuleFiles\ g_loadedModuleVariant g_loadedModuleConflict g_loadedModulePrereq\ g_loadedModulesRefresh g_loadedModuleAltname g_loadedModuleAutoAltname\ g_loadedModuleAliasAltname g_moduleDepend g_dependHash\ g_moduleNPODepend g_dependNPOHash g_prereqViolation\ g_prereqNPOViolation g_conflictViolation g_moduleUnmetDep\ g_unmetDepHash g_moduleEval g_moduleHiddenEval g_scanModuleVariant} { ##nagelfar ignore Suspicious variable name lappend ::g_SAVE_$var [array get ::$var] } # save non-array variable and indication if it was set foreach var {g_changeDir g_stdoutPuts g_prestdoutPuts g_return_text} { ##nagelfar ignore #4 Suspicious variable name if {[info exists ::$var]} { lappend ::g_SAVE_$var [list 1 [set ::$var]] } else { 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_stateCompletes g_Completes\ g_newXResources g_delXResources g_changeDir g_stdoutPuts\ g_prestdoutPuts g_return_text g_loadedModules g_loadedModuleFiles\ g_loadedModuleVariant g_loadedModuleConflict g_loadedModulePrereq\ g_loadedModulesRefresh g_loadedModuleAltname g_loadedModuleAutoAltname\ g_loadedModuleAliasAltname g_moduleDepend g_dependHash\ g_moduleNPODepend g_dependNPOHash g_prereqViolation\ g_prereqNPOViolation g_conflictViolation g_moduleUnmetDep\ g_unmetDepHash g_moduleEval g_moduleHiddenEval g_scanModuleVariant} { ##nagelfar ignore Suspicious variable name set ::g_SAVE_$var [lrange [set ::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_stateCompletes g_Completes\ g_newXResources g_delXResources g_loadedModules g_loadedModuleFiles\ g_loadedModuleVariant g_loadedModuleConflict g_loadedModulePrereq\ g_loadedModulesRefresh g_loadedModuleAltname g_loadedModuleAutoAltname\ g_loadedModuleAliasAltname g_moduleDepend g_dependHash\ g_moduleNPODepend g_dependNPOHash g_prereqViolation\ g_prereqNPOViolation g_conflictViolation g_moduleUnmetDep\ g_unmetDepHash g_moduleEval g_moduleHiddenEval g_scanModuleVariant} { # clear current $var arrays ##nagelfar ignore #5 Suspicious variable name if {[info exists ::$var]} { unset ::$var array set ::$var {} } array set ::$var [lindex [set ::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 {$var ni $envvarlist} { interp-sync-env unset $var } } # restore non-array variable if it was set foreach var {g_changeDir g_stdoutPuts g_prestdoutPuts g_return_text} { ##nagelfar ignore #6 Suspicious variable name if {[info exists ::$var]} { unset ::$var } lassign [lindex [set ::g_SAVE_$var] end] isdefined val if {$isdefined} { set ::$var $val } } reportDebug "previously saved settings restored\ (#[getSavedSettingsStackDepth])" } # load modules passed as args designated as requirement proc loadRequirementModuleList {tryload optional tag_list args} { set ret 0 set prereqloaded 0 # calling procedure must have already parsed module specification in args set loadedmod_list {} foreach mod $args { # get all loaded or loading mod in args list if {[set loadedmod [getLoadedMatchingName $mod returnfirst]] ne {} ||\ [set loadedmod [getLoadedMatchingName $mod returnfirst 1]] ne {}} { lappend loadedmod_list $loadedmod } } if {[llength $loadedmod_list] == 0} { set imax [llength $args] # 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 or if optional set curholdid load-$i-$arg lappendState reportholdid $curholdid if {[catch {set retlo [cmdModuleLoad reqlo 0 $tryload 0 $tag_list\ $arg]} errorMsg]} { # if an error is raised, release output and rethrow the error # (could be raised if no modulepath defined for instance) lpopState reportholdid lappend holdidlist $curholdid report releaseHeldReport {*}$holdidlist knerror $errorMsg } # update return value if an issue occurred in cmdModuleLoad if {$retlo != 0} { set ret $retlo } lpopState reportholdid 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 } } # drop report if not loaded and optional set action [expr {$prereqloaded || !$optional ? {report} : {drop}}] lappend holdidlist $curholdid $action } # output held messages releaseHeldReport {*}$holdidlist } else { set prereqloaded 1 # apply missing tag to all loaded module found cmdModuleTag 0 0 $tag_list {*}$loadedmod_list } return [list $ret $prereqloaded] } # 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] { # record hint that mod will be reloaded (useful in case mod is sticky) lappendState reloading_sticky $mod lappendState reloading_supersticky $mod # save user asked state before it vanishes set isuasked($mod) [isModuleTagged $mod loaded 1] # save variants set for modules set vr($mod) [getVariantList $mod 1 2] # save extra tags set set extratag($mod) [getExtraTagList $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_ [getModuleDesignation loaded\ $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 { lpopState reloading_sticky lpopState reloading_supersticky knerror $errMsg } } lpopState reloading_sticky lpopState reloading_supersticky } return [list [array get isuasked] [array get vr] [array get extratag]] } # load phase of a list of modules reload process proc reloadModuleListLoadPhase {lmname isuaskedlist vrlist extrataglist\ {force 0} {errmsgtpl {}} {context load}} { upvar $lmname lmlist array set isuasked $isuaskedlist array set vr $vrlist array set extratag $extrataglist # 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 { # if an auto set default was excluded, module spec need parsing lassign [parseModuleSpecification 0 0 0 0 $mod {*}$vr($mod)] modnamevr # reload module with user asked property and extra tags preserved if {[cmdModuleLoad $context $isuasked($mod) 0 0 $extratag($mod)\ $modnamevr]} { set errMsg [string map [list _MOD_ [getModuleDesignation spec\ $modnamevr]] $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 } # test if loaded module 'mod' is sticky and if stickiness definition applies # to one of the reloading module proc isStickinessReloading {mod reloading_modlist {tag sticky}} { set res 0 set modname [getModuleNameAndVersFromVersSpec $mod] if {[isModuleTagged $modname $tag 1]} { # evaluate the module-tag commands that are related to mod set dir [getModulepathFromModuleName [getModulefileFromLoadedModule\ $modname] $modname] getModules $dir $modname 0 [list rc_defs_included] set tmodspec [getModuleTag $mod $tag equal 1] # if tag specifically applies to fully qualified module, exact same # module should be found in reload list if {$tmodspec ne {}} { set tmodspec $mod } else { set tmodspec [getModuleTag $mod $tag eqstart 1] } # check if a loading mod satisfies sticky rules foreach modlo $reloading_modlist { if {[modEq $tmodspec $modlo eqstart 1 0 1]} { # found match set res 1 break } } reportDebug "stickiness ($tag) applies to '$tmodspec', is\ reloading=$res" } return $res } # 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]} { # remove existing debug trace if any initProcReportTrace remove modStartNb rename ::modStartNb ::$::g_modStartNb_proc } ##nagelfar syntax modStartNb x x rename ::$procname ::modStartNb # set report traces if some debug mode enabled initProcReportTrace add 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 0 set imax 0 } else { set namesplit [split $modname /] set modsplit [split $mod /] set imax [tcl::mathfunc::min [llength $namesplit] [llength $modsplit]] for {set i 0} {$i < $imax} {incr i} { if {![string equal [lindex $modsplit $i] [lindex $namesplit $i]]} { 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 0 set imax 0 } else { set namesplit [split $modname /] set modsplit [split $mod /] ##nagelfar ignore #2 Badly formed if statement 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]]} { break } } } if {$i == $imax && [modEq $name $mod eqstart]} { incr i } return $i } # 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]} { # remove existing debug trace if any initProcReportTrace remove getEqArrayKey rename ::getEqArrayKey ::$::g_getEqArrayKey_proc } ##nagelfar syntax getEqArrayKey x x rename ::$procname ::getEqArrayKey # set report traces if some debug mode enabled initProcReportTrace add 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] && $dfl in $mrlist} { 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 cmpspec versspec modnamere\ modescglob modroot variantlist modnvspec # 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] && $dfl in $mrlist} { set match $dfl } else { # raise error as no default part of result upvar retlist retlist set retlist [list {} $modnvspec $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 } # 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]} { # remove existing debug trace if any initProcReportTrace remove doesModMatchAtDepth rename ::doesModMatchAtDepth {} } set ::g_doesModMatchAtDepth_procprops $procprops # define optimized procedure if {$indepth} { set atdepth {$mod} } else { set atdepth "\[join \[lrange \[split \$mod /\] 0 $querydepth\] /\]" } ##nagelfar syntax doesModMatchAtDepth x ##nagelfar ignore Non constant argument to proc proc doesModMatchAtDepth {mod} "return \[modEqStatic $atdepth $test *\]" # set report traces if some debug mode enabled initProcReportTrace add doesModMatchAtDepth } } # 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]} { # remove existing debug trace if any initProcReportTrace remove modVersCmp rename ::modVersCmp ::$::g_modVersCmp_proc } ##nagelfar syntax modVersCmp x x x x x? rename ::$procname ::modVersCmp # set report traces if some debug mode enabled initProcReportTrace add modVersCmp set ::g_modVersCmp_proc $procname } } # alternative definitions of modVersCmp proc proc modVersCmpProc {cmpspec versspec modvers test {psuf {}}} { set ret 0 switch -- $cmpspec { in { # check each verspec in list until match foreach inspec $versspec { lassign $inspec incmp invers if {[set ret [modVersCmp $incmp $invers $modvers $test $psuf]]} { break } } } eq { append versspec $psuf if {$test eq {eqstart}} { set ret [string equal -length [string length $versspec/]\ $versspec/ $modvers/] } else { ##nagelfar ignore Non static subcommand set ret [string $test $versspec $modvers] } } 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] && ([versioncmp $modvers\ $versspec] != -1 || [string match $versspec.* $modvers])}] } le { # 'ge' comment also applies here set ret [expr {[isVersion $modvers] && ([versioncmp $versspec\ $modvers] != -1 || [string match $versspec.* $modvers])}] } be { # 'ge' comment also applies here lassign $versspec lovers hivers set ret [expr {[isVersion $modvers] && ([versioncmp $modvers\ $lovers] != -1 || [string match $lovers.* $modvers]) &&\ ([versioncmp $hivers $modvers] != -1 || [string match\ $hivers.* $modvers])}] } } return $ret } proc modVersCmpProcIcase {cmpspec versspec modvers test {psuf {}}} { set ret 0 switch -- $cmpspec { in { foreach inspec $versspec { lassign $inspec incmp invers if {[set ret [modVersCmp $incmp $invers $modvers $test $psuf]]} { break } } } eq { append versspec $psuf if {$test eq {eqstart}} { set ret [string equal -nocase -length [string length $versspec/]\ $versspec/ $modvers/] } else { ##nagelfar ignore Non static subcommand set ret [string $test -nocase $versspec $modvers] } } ge { set ret [expr {[isVersion $modvers] && ([versioncmp $modvers\ $versspec] != -1 || [string match -nocase $versspec.* $modvers])}] } le { set ret [expr {[isVersion $modvers] && ([versioncmp $versspec\ $modvers] != -1 || [string match -nocase $versspec.* $modvers])}] } be { lassign $versspec lovers hivers set ret [expr {[isVersion $modvers] && ([versioncmp $modvers\ $lovers] != -1 || [string match $lovers.* $modvers]) &&\ ([versioncmp $hivers $modvers] != -1 || [string match -nocase\ $hivers.* $modvers])}] } } return $ret } proc modVersCmpProcExtdfl {cmpspec versspec modvers test {psuf {}}} { set ret 0 switch -- $cmpspec { in { foreach inspec $versspec { lassign $inspec incmp invers if {[set ret [modVersCmp $incmp $invers $modvers $test $psuf]]} { break } } } eq { append versspec $psuf if {$test eq {eqstart}} { set ret [string equal -length [string length $versspec/]\ $versspec/ $modvers/] } else { ##nagelfar ignore Non static subcommand set ret [string $test $versspec $modvers] } if {!$ret && [string match $versspec.* $modvers]} { set ret 1 } } ge { set ret [expr {[isVersion $modvers] && ([versioncmp $modvers\ $versspec] != -1 || [string match $versspec.* $modvers])}] } le { set ret [expr {[isVersion $modvers] && ([versioncmp $versspec\ $modvers] != -1 || [string match $versspec.* $modvers])}] } be { lassign $versspec lovers hivers set ret [expr {[isVersion $modvers] && ([versioncmp $modvers\ $lovers] != -1 || [string match $lovers.* $modvers]) &&\ ([versioncmp $hivers $modvers] != -1 || [string match\ $hivers.* $modvers])}] } } return $ret } proc modVersCmpProcIcaseExtdfl {cmpspec versspec modvers test {psuf {}}} { set ret 0 switch -- $cmpspec { in { foreach inspec $versspec { lassign $inspec incmp invers if {[set ret [modVersCmp $incmp $invers $modvers $test $psuf]]} { break } } } eq { append versspec $psuf if {$test eq {eqstart}} { set ret [string equal -nocase -length [string length $versspec/]\ $versspec/ $modvers/] } else { ##nagelfar ignore Non static subcommand set ret [string $test -nocase $versspec $modvers] } if {!$ret && [string match -nocase $versspec.* $modvers]} { set ret 1 } } ge { set ret [expr {[isVersion $modvers] && ([versioncmp $modvers\ $versspec] != -1 || [string match -nocase $versspec.* $modvers])}] } le { set ret [expr {[isVersion $modvers] && ([versioncmp $versspec\ $modvers] != -1 || [string match -nocase $versspec.* $modvers])}] } be { lassign $versspec lovers hivers set ret [expr {[isVersion $modvers] && ([versioncmp $modvers\ $lovers] != -1 || [string match $lovers.* $modvers]) &&\ ([versioncmp $hivers $modvers] != -1 || [string match -nocase\ $hivers.* $modvers])}] } } return $ret } proc modVariantCmp {pvrlist modvrlist {missmean 0}} { set ret 1 # missing variant in mod spec means default value if {$missmean == 1} { foreach {modvrname modvrval modvrisdfl} $modvrlist { set modvrarr($modvrname) $modvrval set modvrisdflarr($modvrname) $modvrisdfl } } else { array set modvrarr $modvrlist # if missmean == 2 pattern is mod, thus missing variant on mod is ok # it is used for extra specifier where pattern is definition inside # modulefile and mod is extra specifier defined on command line } foreach pvr $pvrlist { set pvrarr([lindex $pvr 0]) [lindex $pvr 1] } # no match if a specified variant is not found among module variants (and # if miss is not ok) or if the value differs foreach vrname [array names pvrarr] { if {(![info exists modvrarr($vrname)] && $missmean != 2) || ([info\ exists modvrarr($vrname)] && $pvrarr($vrname) ne\ $modvrarr($vrname))} { set ret 0 break } } # if an unset variant on pattern means variant default value pattern and # mod are not equal if variant unset on pattern and non-default value is # set for variant on mod if {$missmean == 1} { foreach vrname [array names modvrisdflarr] { if {!$modvrisdflarr($vrname) && ![info exists pvrarr($vrname)]} { set ret 0 break } } } 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. # modEqStatic does not compare against loaded modules so it has no need to # compare variants set on module specification 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]} { # remove existing debug trace if any initProcReportTrace remove modEqStatic 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 # trim dup trailing / char and adapt pmod suffix if it starts with / if {[string index $pmod end] eq {/}} { set pmod [string trimright $pmod /]/ set endwslash 1 } else { set endwslash 0 } set nocasearg [expr {$icase ? {-nocase } : {}}] set pmodnameslen [string length $pmodname/] if {$pmod ne {} || $modspec eq {}} { set procbody " set pmod {$pmod} if {\$psuf ne {}} { if {$endwslash && \[string index \$psuf 0\] eq {/}} { append pmod \[string range \$psuf 1 end\] } else { 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" ##nagelfar syntax modEqStatic x x? x? ##nagelfar ignore Non constant argument to proc proc modEqStatic {mod {test equal} {psuf {}}} $procbody # set report traces if some debug mode enabled initProcReportTrace add modEqStatic } } # Define procedure to check module name equals pattern. Adapt procedure # code whether icase and extended_default are enabled or disabled proc defineModEqProc {icase extdfl {loadedmod 0}} { 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]} { # remove existing debug trace if any initProcReportTrace remove modEq rename ::modEq ::$::g_modEq_proc } ##nagelfar syntax modEq x x x? x? x? x? x? x? rename ::$procname ::modEq # set report traces if some debug mode enabled initProcReportTrace add modEq set ::g_modEq_proc $procname } # also define modVersCmp which is called by modEq defineModVersCmpProc $icase $extdfl # comparing against loaded modules requires to know their alternative names if {$loadedmod} { cacheCurrentModules } } # alternative definitions of modEq proc proc modEqProc {pattern mod {test equal} {trspec 1} {ismodlo 0} {vrcmp 0}\ {modvrlist 0} {psuf {}}} { # extract specified module name from name and version spec if {$trspec} { lassign [getModuleVersSpec $pattern] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob pmodroot pvrlist } else { set pmod $pattern } # trim dup trailing / char and adapt pmod suffix if it starts with / if {[string index $pmod end] eq {/}} { set pmod [string trimright $pmod /]/ set endwslash 1 } else { set endwslash 0 } # get alternative names if mod is loading(1) or loaded(2) set altlist [switch -- $ismodlo { 5 {getAvailListFromVersSpec $mod} 4 {getAllModuleResolvedName $mod 0 {} 1} 3 {getLoadedAltAndSimplifiedName $mod} 2 {getLoadedAltname $mod} 1 {getAllModuleResolvedName $mod} 0 {list}}] # fetch variant definition from spec if not loaded/loading if {$vrcmp && $ismodlo in {0 5}} { set modvrlist [getVariantList $mod 0 0 1] set mod [getModuleNameAndVersFromVersSpec $mod] } # specified module can be translated in a simple mod name/vers or is empty if {$pmod ne {} || $pattern eq {}} { if {$psuf ne {}} { if {$endwslash && [string index $psuf 0] eq {/}} { append pmod [string range $psuf 1 end] } else { append pmod $psuf } } if {$test eq {eqstart}} { set ret [string equal -length [string length $pmod/] $pmod/ $mod/] # apply comparison to alternative names if any and no match for mod if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {[set ret [string equal -length [string length $pmod/]\ $pmod/ $alt/]]} { break } } } } else { # contains test if {$test eq {matchin}} { set test match set pmod *$pmod } elseif {$test eq {eqspec}} { set test equal } ##nagelfar ignore Non static subcommand set ret [string $test $pmod $mod] # apply comparison to alternative names if any and no match for mod if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { ##nagelfar ignore Non static subcommand if {[set ret [string $test $pmod $alt]]} { break } } } } } elseif {$test eq {eqspec}} { # test equality against all version described in spec (list or range # boundaries), trspec is considered enabled and psuf empty foreach pmod [getAllModulesFromVersSpec $pattern] { if {[set ret [string equal $pmod $mod]]} { break } } } 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 } # apply comparison to alternative names if any and no match for mod if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {($pmodnamere ne {} && $test eq {match} && [regexp\ (^$pmodnamere)/ $alt/ rematch pmodname]) || [string equal\ -length [string length $pmodname/] $pmodname/ $alt/]} { # then compare versions set modvers [string range $alt [string length $pmodname/] end] if {[set ret [modVersCmp $cmpspec $versspec $modvers $test\ $psuf]]} { break } } } } } # check if variant specified matches those of selected loaded/ing module if {$ret && $vrcmp && $ismodlo ni {3 5} && [llength $pvrlist] > 0} { if {$modvrlist eq {0}} { set modvrlist [getVariantList $mod] } set ret [modVariantCmp $pvrlist $modvrlist] # variant miss means variant default val when comparing collection content } elseif {$ret && $vrcmp && $ismodlo == 3} { set ret [modVariantCmp $pvrlist [getVariantList $mod 3] 1] # variant miss is ok when comparing an extra specifier passed as mod } elseif {$ret && $vrcmp && $ismodlo == 5} { set ret [modVariantCmp $pvrlist $modvrlist 2] } return $ret } proc modEqProcIcase {pattern mod {test equal} {trspec 1} {ismodlo 0} {vrcmp\ 0} {modvrlist 0} {psuf {}}} { if {$trspec} { lassign [getModuleVersSpec $pattern] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob pmodroot pvrlist } else { set pmod $pattern } if {[string index $pmod end] eq {/}} { set pmod [string trimright $pmod /]/ set endwslash 1 } else { set endwslash 0 } set altlist [switch -- $ismodlo { 5 {getAvailListFromVersSpec $mod} 4 {getAllModuleResolvedName $mod 0 {} 1} 3 {getLoadedAltAndSimplifiedName $mod} 2 {getLoadedAltname $mod} 1 {getAllModuleResolvedName $mod} 0 {list}}] if {$vrcmp && $ismodlo in {0 5}} { set modvrlist [getVariantList $mod 0 0 1] set mod [getModuleNameAndVersFromVersSpec $mod] } if {$pmod ne {} || $pattern eq {}} { if {$psuf ne {}} { if {$endwslash && [string index $psuf 0] eq {/}} { append pmod [string range $psuf 1 end] } else { append pmod $psuf } } if {$test eq {eqstart}} { set ret [string equal -nocase -length [string length $pmod/] $pmod/\ $mod/] if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {[set ret [string equal -nocase -length [string length\ $pmod/] $pmod/ $alt/]]} { break } } } } else { # contains test if {$test eq {matchin}} { set test match set pmod *$pmod } elseif {$test eq {eqspec}} { set test equal } ##nagelfar ignore Non static subcommand set ret [string $test -nocase $pmod $mod] if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { ##nagelfar ignore Non static subcommand if {[set ret [string $test -nocase $pmod $alt]]} { break } } } } } elseif {$test eq {eqspec}} { # test equality against all version described in spec (list or range # boundaries), trspec is considered enabled and psuf empty foreach pmod [getAllModulesFromVersSpec $pattern] { if {[set ret [string equal -nocase $pmod $mod]]} { break } } } 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 } if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {($pmodnamere ne {} && $test eq {match} && [regexp -nocase\ (^$pmodnamere)/ $alt/ rematch pmodname]) || [string equal\ -nocase -length [string length $pmodname/] $pmodname/ $alt/]} { # then compare versions set modvers [string range $alt [string length $pmodname/] end] if {[set ret [modVersCmp $cmpspec $versspec $modvers $test\ $psuf]]} { break } } } } } if {$ret && $vrcmp && $ismodlo ni {3 5} && [llength $pvrlist] > 0} { if {$modvrlist eq {0}} { set modvrlist [getVariantList $mod] } set ret [modVariantCmp $pvrlist $modvrlist] } elseif {$ret && $vrcmp && $ismodlo == 3} { set ret [modVariantCmp $pvrlist [getVariantList $mod 3] 1] } elseif {$ret && $vrcmp && $ismodlo == 5} { set ret [modVariantCmp $pvrlist $modvrlist 2] } return $ret } proc modEqProcExtdfl {pattern mod {test equal} {trspec 1} {ismodlo 0} {vrcmp\ 0} {modvrlist 0} {psuf {}}} { if {$trspec} { lassign [getModuleVersSpec $pattern] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob pmodroot pvrlist } else { set pmod $pattern } if {[string index $pmod end] eq {/}} { set pmod [string trimright $pmod /]/ set endwslash 1 } else { set endwslash 0 } set altlist [switch -- $ismodlo { 5 {getAvailListFromVersSpec $mod} 4 {getAllModuleResolvedName $mod 0 {} 1} 3 {getLoadedAltAndSimplifiedName $mod} 2 {getLoadedAltname $mod} 1 {getAllModuleResolvedName $mod} 0 {list}}] if {$vrcmp && $ismodlo in {0 5}} { set modvrlist [getVariantList $mod 0 0 1] set mod [getModuleNameAndVersFromVersSpec $mod] } if {$pmod ne {} || $pattern eq {}} { if {$psuf ne {}} { if {$endwslash && [string index $psuf 0] eq {/}} { append pmod [string range $psuf 1 end] } else { append pmod $psuf } } if {$test eq {eqstart}} { set ret [string equal -length [string length $pmod/] $pmod/ $mod/] if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {[set ret [string equal -length [string length $pmod/]\ $pmod/ $alt/]]} { break } } } } else { # contains test if {$test eq {matchin}} { set test match set pmod *$pmod } elseif {$test eq {eqspec}} { set test equal set eqspec 1 } ##nagelfar ignore Non static subcommand set ret [string $test $pmod $mod] if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { ##nagelfar ignore Non static subcommand if {[set ret [string $test $pmod $alt]]} { break } } } } # try the extended default match if not root module and not eqspec test if {![info exists eqspec] && !$ret && [string first / $pmod] != -1} { if {$test eq {match}} { set pmodextdfl $pmod.* } else { set pmodextdfl $pmodescglob.* } set ret [string match $pmodextdfl $mod] if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {[set ret [string match $pmodextdfl $alt]]} { break } } } } } elseif {$test eq {eqspec}} { # test equality against all version described in spec (list or range # boundaries), trspec is considered enabled and psuf empty foreach pmod [getAllModulesFromVersSpec $pattern] { if {[set ret [string equal $pmod $mod]]} { break } } } 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 } if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {($pmodnamere ne {} && $test eq {match} && [regexp\ (^$pmodnamere)/ $alt/ rematch pmodname]) || [string equal\ -length [string length $pmodname/] $pmodname/ $alt/]} { # then compare versions set modvers [string range $alt [string length $pmodname/] end] if {[set ret [modVersCmp $cmpspec $versspec $modvers $test\ $psuf]]} { break } } } } } if {$ret && $vrcmp && $ismodlo ni {3 5} && [llength $pvrlist] > 0} { if {$modvrlist eq {0}} { set modvrlist [getVariantList $mod] } set ret [modVariantCmp $pvrlist $modvrlist] } elseif {$ret && $vrcmp && $ismodlo == 3} { set ret [modVariantCmp $pvrlist [getVariantList $mod 3] 1] } elseif {$ret && $vrcmp && $ismodlo == 5} { set ret [modVariantCmp $pvrlist $modvrlist 2] } return $ret } proc modEqProcIcaseExtdfl {pattern mod {test equal} {trspec 1} {ismodlo 0}\ {vrcmp 0} {modvrlist 0} {psuf {}}} { if {$trspec} { lassign [getModuleVersSpec $pattern] pmod pmodname cmpspec versspec\ pmodnamere pmodescglob pmodroot pvrlist } else { set pmod $pattern } if {[string index $pmod end] eq {/}} { set pmod [string trimright $pmod /]/ set endwslash 1 } else { set endwslash 0 } set altlist [switch -- $ismodlo { 5 {getAvailListFromVersSpec $mod} 4 {getAllModuleResolvedName $mod 0 {} 1} 3 {getLoadedAltAndSimplifiedName $mod} 2 {getLoadedAltname $mod} 1 {getAllModuleResolvedName $mod} 0 {list}}] if {$vrcmp && $ismodlo in {0 5}} { set modvrlist [getVariantList $mod 0 0 1] set mod [getModuleNameAndVersFromVersSpec $mod] } if {$pmod ne {} || $pattern eq {}} { if {$psuf ne {}} { if {$endwslash && [string index $psuf 0] eq {/}} { append pmod [string range $psuf 1 end] } else { append pmod $psuf } } if {$test eq {eqstart}} { set ret [string equal -nocase -length [string length $pmod/] $pmod/\ $mod/] if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {[set ret [string equal -nocase -length [string length\ $pmod/] $pmod/ $alt/]]} { break } } } } else { # contains test if {$test eq {matchin}} { set test match set pmod *$pmod } elseif {$test eq {eqspec}} { set test equal set eqspec 1 } ##nagelfar ignore Non static subcommand set ret [string $test -nocase $pmod $mod] if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { ##nagelfar ignore Non static subcommand if {[set ret [string $test -nocase $pmod $alt]]} { break } } } } # try the extended default match if not root module and not eqspec test if {![info exists eqspec] && !$ret && [string first / $pmod] != -1} { if {$test eq {match}} { set pmodextdfl $pmod.* } else { set pmodextdfl $pmodescglob.* } set ret [string match -nocase $pmodextdfl $mod] if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {[set ret [string match -nocase $pmodextdfl $alt]]} { break } } } } } elseif {$test eq {eqspec}} { # test equality against all version described in spec (list or range # boundaries), trspec is considered enabled and psuf empty foreach pmod [getAllModulesFromVersSpec $pattern] { if {[set ret [string equal -nocase $pmod $mod]]} { break } } } 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 } if {!$ret && [llength $altlist] > 0} { foreach alt $altlist { if {($pmodnamere ne {} && $test eq {match} && [regexp -nocase\ (^$pmodnamere)/ $alt/ rematch pmodname]) || [string equal\ -nocase -length [string length $pmodname/] $pmodname/ $alt/]} { # then compare versions set modvers [string range $alt [string length $pmodname/] end] if {[set ret [modVersCmp $cmpspec $versspec $modvers $test\ $psuf]]} { break } } } } } if {$ret && $vrcmp && $ismodlo ni {3 5} && [llength $pvrlist] > 0} { if {$modvrlist eq {0}} { set modvrlist [getVariantList $mod] } set ret [modVariantCmp $pvrlist $modvrlist] } elseif {$ret && $vrcmp && $ismodlo == 3} { set ret [modVariantCmp $pvrlist [getVariantList $mod 3] 1] } elseif {$ret && $vrcmp && $ismodlo == 5} { set ret [modVariantCmp $pvrlist $modvrlist 2] } return $ret } # analyze module version specified within module specification proc parseModuleVersionSpecifier {modspec} { set invalidversspec 0 set invalidversrange 0 set islist [expr {[string first , $modspec] != -1}] set isrange [expr {[string first : $modspec] != -1}] # no deep version specification allowed if {[string first / $modspec] != -1} { set invalidversspec 1 # ',' separates multiple versions } elseif {$islist} { set cmpspec in set inspeclist [split $modspec ,] # empty element in list is erroneous set invalidversspec [expr {[lsearch -exact $inspeclist {}] != -1}] if {!$invalidversspec} { # recursive call to check each element in list (can be range, etc) foreach inspec $inspeclist { lappend versspec [parseModuleVersionSpecifier $inspec] } } # ':' separates range elements } elseif {$isrange} { 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 {[versioncmp $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'" } return [list $cmpspec $versspec] } # Define procedure to parse modulefile specification passed as argument # Adapt procedure code whether advanced_version_spec is enabled or disabled proc defineParseModuleSpecificationProc {advverspec} { set procname parseModuleSpecificationProc if {$advverspec} { append procname AdvVersSpec # resolved configured variant shortcut getConf variant_shortcut } # define proc if not done yet or if it was defined for another context if {[info procs parseModuleSpecification] eq {} ||\ $::g_parseModuleSpecification_proc ne $procname} { if {[info exists ::g_parseModuleSpecification_proc]} { # remove existing debug trace if any initProcReportTrace remove parseModuleSpecification rename ::parseModuleSpecification\ ::$::g_parseModuleSpecification_proc } ##nagelfar syntax parseModuleSpecification x x x x x* rename ::$procname ::parseModuleSpecification # set report traces if some debug mode enabled initProcReportTrace add parseModuleSpecification set ::g_parseModuleSpecification_proc $procname } } # when advanced_version_spec option is enabled, parse argument list to set in # a global context version specification of modules passed as argument. # mlspec: specification may vary whether it comes from the ml or another # command. nonamespec: sometimes specification may omit module name and # version and just provides variant properties. xtspec: is extra specifier # specification allowed. getavails: query available modules to get those # matching module name and version proc parseModuleSpecificationProc {mlspec nonamespec xtspec getavails 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]} { return $args } 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 {} {} {} $arg {} $getavails # append to unload list if ml spec and - prefix used if {$mlunload} { lappend unarglist $modarg } else { lappend arglist $modarg } } if {$mlspec} { return [list $unarglist $arglist] } else { return $arglist } } proc parseModuleSpecificationProcAdvVersSpec {mlspec nonamespec xtspec\ getavails args} { foreach arg $args { if {![info exists ::g_moduleVersSpec($arg)]} { set need_parse 1 break } } if {![info exists need_parse]} { return $args } # define extra specifier known list, to raise error if argument does not # match set xtelt_valid_list [list always-load append-path chdir complete conflict\ depends-on envvar family incompat load load-any prepend-path prereq\ prereq-all prereq-any pushenv remove-path require set-alias\ set-function setenv switch switch-on switch-off try-load uncomplete\ unload unset-alias unset-function unsetenv variant] set xtelt_modspec_list [list always-load conflict depends-on incompat load\ load-any prereq prereq-all prereq-any require switch switch-on\ switch-off try-load unload] set mlunload 0 set nextmlunload 0 set arglist [list] set unarglist [list] set vrlist [list] set vridx -1 set xtlist [list] set rawarg [list] foreach arg $args { # set each specification element as separate word but preserve space # character in each arg set curarglist {} # skip argument split if extra specifier detected if {[regexp {^[a-z-]+:} $arg]} { lappend curarglist $arg } else { set previ 0 for {set i 1} {$i < [string length $arg]} {incr i} { set c [string index $arg $i] switch -- $c { @ - ~ { lappend curarglist [string range $arg $previ $i-1] set previ $i } + { # allow one or more '+' char at end of module name if not # followed by non-special character (@, ~ or /) set nexti [expr {$i + 1}] if {$nexti < [string length $arg]} { switch -- [string index $arg $nexti] { @ - + - ~ - / {} default { lappend curarglist [string range $arg $previ $i-1] set previ $i } } } } default { # check if a variant shortcut matches if {[info exists ::g_shortcutVariant($c)]} { lappend curarglist [string range $arg $previ $i-1] set previ $i } } } } lappend curarglist [string range $arg $previ $i-1] } # parse each specification element foreach curarg $curarglist { set vrisbool 0 set c [string index $curarg 0] switch -- $c { @ { set modspec [string range $curarg 1 end] lassign [parseModuleVersionSpecifier $modspec] cmpspec versspec continue } + { set curarg [string range $curarg 1 end] append curarg =1 set vrisbool 1 } - { set curarg [string range $curarg 1 end] if {$mlspec} { set nextmlunload 1 } else { append curarg =0 set vrisbool 1 } } ~ { set curarg [string range $curarg 1 end] append curarg =0 set vrisbool 1 } default { # translate shortcut in variant name in arg if {[info exists ::g_shortcutVariant($c)]} { set curarg [string replace $curarg 0 0\ $::g_shortcutVariant($c)=] } } } switch -glob -- $curarg { *:* { # extra specification may not be accepted on current context if {!$xtspec} { knerror "No extra specification allowed on this command" } # extract extra specifier spec set xtsepidx [string first : $curarg] set xtelt [string range $curarg 0 $xtsepidx-1] set xtname [string range $curarg $xtsepidx+1 end] # check no other : character is found in argument or element # and name are not an empty string if {[string length $xtelt] == 0 || [string length $xtname] ==\ 0 || ([string last : $curarg] != $xtsepidx && $xtelt ni\ $xtelt_modspec_list)} { knerror "Invalid extra specification '$arg'" } if {$xtelt ni $xtelt_valid_list} { knerror "Invalid extra specifier '$xtelt'\nValid extra\ specifiers are: $xtelt_valid_list" } # parse and resolve module spec set as extra specifier value if {$xtelt in $xtelt_modspec_list} { lassign [parseModuleSpecification 0 0 0 1 {*}$xtname] xtname } # save extra specifier element and name value, same element can # appear multiple time (means AND operator) lappend xtlist [list $xtelt $xtname] } *=* { # extract valued-variant spec set vrsepidx [string first = $curarg] set vrname [string range $curarg 0 $vrsepidx-1] set vrvalue [string range $curarg $vrsepidx+1 end] if {$vrname eq {}} { knerror "No variant name defined in argument '$curarg'" } # check no other = character is found in argument if {[string last = $curarg] != $vrsepidx} { knerror "Invalid variant specification '$arg'" } # replace previous value for variant if already set if {[info exists vrnamearr($vrname)]} { lreplace $vrlist $vrnamearr($vrname) $vrnamearr($vrname) } else { incr vridx } # translate boolean vrvalue in canonical boolean if {!$vrisbool && [string is boolean -strict $vrvalue] &&\ ![string is integer -strict $vrvalue]} { set vrisbool 1 set vrvalue [string is true -strict $vrvalue] } # save variant name and value set vrnamearr($vrname) $vridx lappend vrlist [list $vrname $vrvalue $vrisbool] } default { # save previous mod version spec and transformed arg if any if {[info exists modarglist]} { set modarg [join $modarglist] if {![info exists cmpspec]} { set cmpspec eq set versspec {} } # wild search name if no module name allowed if {$nonamespec && ![info exists modname]} { set modname * set modspec * } if {[info exists modname] && ($modname ne {} || $modspec\ eq {})} { setModuleVersSpec $modarg $modname $cmpspec $versspec\ $modspec $vrlist $rawarg $xtlist $getavails # rework args to have 1 str element for whole mod spec # append to unload list if ml spec and - prefix used if {$mlunload} { lappend unarglist $modarg } else { lappend arglist $modarg } } else { knerror "No module name defined in argument '$modarg'" } unset modarglist set vrlist [list] array unset vrnamearr set vridx -1 set xtlist [list] set rawarg [list] unset cmpspec versspec } set mlunload $nextmlunload set nextmlunload 0 set modname $curarg set modspec {} } } } lappend rawarg $arg # keep arg enclosed if composed of several words if {[string first { } $arg] != -1} { lappend modarglist "{$arg}" } else { lappend modarglist $arg } } # transform last args set modarg [join $modarglist] if {$nonamespec && ![info exists modname]} { set modname * set modspec * } if {[info exists modname] && ($modname ne {} || $modspec eq {})} { if {![info exists cmpspec]} { set cmpspec eq set versspec {} } setModuleVersSpec $modarg $modname $cmpspec $versspec $modspec $vrlist\ $rawarg $xtlist $getavails # rework args to have 1 string element for whole module spec # append to unload list if ml spec and - prefix used if {$mlunload || $nextmlunload} { lappend unarglist $modarg } else { lappend arglist $modarg } } else { knerror "No module name defined in argument '$modarg'" } if {$mlspec} { return [list $unarglist $arglist] } else { return $arglist } } proc setModuleVersSpec {modarg modname cmpspec versspec rawversspec\ variantlist rawarg extralist getavails} { # translate @loaded version into currently loaded mod matching modname if {$cmpspec eq {eq} && $versspec eq {loaded}} { if {[set lmmod [getLoadedMatchingName $modname]] ne {}} { set modname [file dirname $lmmod] set versspec [file tail $lmmod] set variantlist [getVariantList $lmmod 2] } else { knerror "No loaded version found for '$modname' module" } } # save module root name set modroot [lindex [file split $modname] 0] # save module single designation if any and module name 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] # save module name and version specification (without variant specs) if {$mod eq {} && $rawversspec ne {} && $modname ne {.}} { set modnvspec ${modname}@${rawversspec} } else { set modnvspec $mod } # record most of the spec now to be able to rely on this record to get # matching available modules set ::g_moduleVersSpec($modarg) [list $mod $modname $cmpspec $versspec\ $modnamere $modescglob $modroot $variantlist $modnvspec $rawarg\ $extralist] # get all available module name and version matching module name and # version spec (inhibit extra match search not to trigger an infinite loop) if {$getavails} { setState inhibit_ems 1 set availlist [getAllAvailModule $modarg] setState inhibit_ems 0 } else { set availlist {} } # finalize module version spec record lappend ::g_moduleVersSpec($modarg) $availlist reportDebug "Set module '$mod' (escglob '$modescglob'), module name\ '$modname' (re '$modnamere'), module root '$modroot', version cmp\ '$cmpspec', version(s) '$versspec', variant(s) '$variantlist' and\ module name version spec '$modnvspec' for argument '$modarg' (raw\ '$rawarg'), extra specifier(s) '$extralist' and matching available\ module(s) '$availlist'" } proc getModuleVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { return $::g_moduleVersSpec($modarg) } else { return [list $modarg [file dirname $modarg] {} {} {} [string map {* \\*\ ? \\?} $modarg] [lindex [file split $modarg] 0] {} $modarg $modarg\ {} {}] } } proc unsetModuleVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { unset ::g_moduleVersSpec($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 } # get module root name from module name and version spec if parsed proc getModuleRootFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { set modroot [lindex $::g_moduleVersSpec($modarg) 6] } else { set modroot [lindex [file split $modarg] 0] } return $modroot } # translate module name version spec to return all modules mentioned proc getAllModulesFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { lassign $::g_moduleVersSpec($modarg) mod modname cmpspec versspec if {$mod eq {} && $cmpspec eq {in}} { # loop around each spec in list foreach inspec $versspec { lassign $inspec incmp invers foreach vers $invers { lappend modlist $modname/$vers } } } elseif {$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 mentioned proc getOneModuleFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { lassign $::g_moduleVersSpec($modarg) mod modname cmpspec versspec if {$mod eq {} && $cmpspec eq {in}} { set inspec [lindex $versspec 0] lassign $inspec incmp invers set mod $modname/[lindex $invers 0] } elseif {$mod eq {} && $cmpspec ne {eq}} { set mod $modname/[lindex $versspec 0] } } else { set mod $modarg } return $mod } # translate module name version spec to return the list of variant mentioned proc getVariantListFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { set variantlist [lindex $::g_moduleVersSpec($modarg) 7] } else { set variantlist {} } return $variantlist } # get module name and version from version spec if parsed proc getModuleNameAndVersFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { set modnvspec [lindex $::g_moduleVersSpec($modarg) 8] } else { set modnvspec $modarg } return $modnvspec } # get raw argument specified from parsed version spec proc getRawArgumentFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { set rawarg [lindex $::g_moduleVersSpec($modarg) 9] } else { set rawarg $modarg } return $rawarg } # translate module name version spec to return the list of extra specifier # mentioned proc getExtraListFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { set extralist [lindex $::g_moduleVersSpec($modarg) 10] } else { set extralist {} } return $extralist } # get available modules matching module specification proc getAvailListFromVersSpec {modarg} { if {[info exists ::g_moduleVersSpec($modarg)]} { set availlist [lindex $::g_moduleVersSpec($modarg) 11] } else { set availlist {} } return $availlist } # is mod spec containing variant but no module name and version proc isSpecWildWithVariant {mod} { return [expr {[getModuleNameAndVersFromVersSpec $mod] eq {*} && [llength\ [getVariantListFromVersSpec $mod]] > 0}] } # Get full path name of module cache file for given modulepath proc getModuleCacheFilename {modpath} { return $modpath/.modulecache } # test if a given file path has a limited access by check permission mode set # for others proc isFileAccessLimited {fpath isdir} { # check if file stat info can be fetched if {[file readable $fpath]} { # extract permissions for "other" set other_perms [string index [file attributes $fpath -permissions] end] # test file can be read by other: o+r right, which means file should at # least have 0b100 mode, which can be binary-compared against 0b011 (3) # if file is a directory, test it can also be searched: o+x right, which # means dir should at least have 0b101 mode, which can be compared # against 0b010 (2) set perms_mask [expr {$isdir ? {2} : {3}}] set ret [expr {($other_perms | $perms_mask) != 7}] } else { set ret 1 } return $ret } # walk through directory content and return every files and dirs with limited # access rights proc getLimitedAccessesInDirectory {modpath} { # cannot test limited accesses on Windows platform if {[getState is_win]} { return {} } foreach igndir [getConf ignored_dirs] { set ignored_dirs($igndir) 1 } # walk through directory to find elements with limited access array set limited_arr {} lappend full_list $modpath for {set i 0} {$i < [llength $full_list]} {incr i 1} { set elt [lindex $full_list $i] set elttail [file tail $elt] set eltname [getModuleNameFromModulepath $elt $modpath] if {[file isdirectory $elt]} { # skip ignored dirs if {![info exists ignored_dirs($elttail)]} { if {[isFileAccessLimited $elt 1]} { set limited_arr($eltname) d # only walk through directory content if its access is not limited } else { # get all elements found in directory (regular and dot files) set direlt_list [glob -nocomplain $elt/*] foreach eltindir [glob -nocomplain -types hidden -directory\ $elt -tails *] { if {$eltindir ni {. ..}} { lappend direlt_list $elt/$eltindir } } if {[llength $direlt_list] > 0} { lappend full_list {*}$direlt_list } } } } else { # skip ignored files switch -glob -- $elttail { *~ - *,v - \#*\# {} default { if {[isFileAccessLimited $elt 0]} { set limited_arr($eltname) f } } } } } # filter .version/.modulecache files found at the root of modulepath dir foreach elt [list .version .modulecache] { if {[info exists limited_arr($elt)]} { unset limited_arr($elt) } } reportDebug "found [array names limited_arr] ([array size limited_arr])\ with limited access" return [array get limited_arr] } # Build cache file content for given modulepath proc formatModuleCacheContent {modpath} { set content {} # collect files from modulepath directory array set found_list [findModules $modpath * 0 1] # collect files and dirs from modulepath directory with limited access array set limited_list [getLimitedAccessesInDirectory $modpath] # concatenate element found and those with limited access as the second # kind may not be part of found list set elt_list [lsort -unique [concat [array names found_list] [array names\ limited_list]]] # build cache entry for every file found foreach elt $elt_list { # ignore element if it has been flagged in skip list (one of its parent # directory has limited access) or if modulepath has itself a limited # access if {[info exists skip_list($elt)] || $elt eq {}} { continue } set entry_list [list] set fetch_content 0 # mention in cache that file or directory has limited access to test if # they can be accessed by user when cache is evaluated if {[info exists limited_list($elt)]} { if {$limited_list($elt) eq {d}} { # mark all elements contained in dir to skip them as their parent # directory has limited access (due to lsort on foreach loop we # are assured to treat parent dir before the entries it contains) foreach elttoskip [array names found_list -glob $elt/*] { set skip_list($elttoskip) 1 } lappend entry_list limited-access-directory $elt } else { lappend entry_list limited-access-file $elt } } else { switch -- [lindex $found_list($elt) 0] { modulerc { lappend entry_list modulerc-content $elt set fetch_content 1 } modulefile { lappend entry_list modulefile-content $elt [lindex\ $found_list($elt) 1] set fetch_content 1 } default { # also record obtained error to get all the information to # cover everything fetched by findModules. only modulefile # validity is checked in findModules lappend entry_list modulefile-invalid $elt {*}[lrange\ $found_list($elt) 0 1] } } } # fetch file content if {$fetch_content} { if {[catch { set fcontent [readFile $modpath/$elt] # extract module header from the start of the file if {![regexp {^#%Module[0-9\.]*} [string range $fcontent 0 32]\ fheader]} { set fheader {} } lappend entry_list $fheader $fcontent } errMsg]} { # rethrow read error after parsing message knerror [parseAccessIssue $modpath/$elt] } } # format cache entry append content "\n$entry_list" } # prepend header if some content has been generated if {[string length $content] != 0} { regexp {^\d+\.\d+} {5.3.0} majmin set content "#%Module$majmin$content" } return $content } # read a cache file proc readCacheContent {cachefile} { set res {} if {[catch { # read full file set fid [open $cachefile r] # use defined buffer size to limit number of read system call fconfigure $fid -buffersize [getConf cache_buffer_bytes] set fdata [read $fid] close $fid # extract magic cookie (first word of cache file) set fh [string trimright [lindex [split [string range $fdata 0 32]]\ 0] #] set fhvers [string range $fh 8 end] } errMsg ]} { reportError [parseAccessIssue $cachefile] } else { # check cache validity if {![string equal -length 8 $fh {#%Module}]} { reportInternalBug {Magic cookie '#%Module' missing} $cachefile\ {Cache ERROR} # check if version requirement is present } elseif {[string length $fh] <= 8} { reportInternalBug {Modules version requirement missing} $cachefile\ {Cache ERROR} # check if min version requirement is met } elseif {[versioncmp {5.3.0} $fhvers] <0} { reportInternalBug "Cache file requires at least Modules version\ $fhvers" $cachefile {Cache ERROR} } else { # set file content as result set res $fdata } } return $res } # evaluate cache file proc execute-cachefile {cachefile modpath} { # register current modulepath for cachefile commands to know where they are lappendState modulepath $modpath lappendState debug_msg_prefix "\[cache:$cachefile\] " # initialize cache gathering structures for modulepath set ::g_cacheModpath($modpath) {} set ::g_cacheFLimitedModpath($modpath) {} set ::g_cacheDLimitedModpath($modpath) {} # initialize cache file evaluation interp configuration if {![info exists ::g_cachefileUntrackVars]} { # list variable that should not be tracked for saving array set ::g_cachefileUntrackVars [list ModulesCurrentCachefile 1\ cachecontent 1 env 1] # commands that should be renamed before aliases setup array set ::g_cachefileRenameCmds [list] # list interpreter alias commands to define array set ::g_cachefileAliases [list modulefile-content\ modulefile-content modulerc-content modulerc-content\ modulefile-invalid modulefile-invalid limited-access-file\ limited-access-file limited-access-directory\ limited-access-directory reportInternalBug reportInternalBug\ readCacheContent readCacheContent formatErrStackTrace\ formatErrStackTrace] # alias commands where an argument should be passed array set ::g_cachefileAliasesPassArg [list] # trace commands that should be associated to aliases array set ::g_cachefileAliasesTraces [list] } set itrp __cachefile reportTrace '$cachefile' {Evaluate cache file} # create cachefile interpreter at first interpretation if {![interp exists $itrp]} { reportDebug "creating interp $itrp" interp create $itrp # dump initial interpreter state to restore it before each cachefile # interpretation. dumpInterpState $itrp g_cachefileVars g_cachefileArrayVars\ g_cachefileUntrackVars g_cachefileProcs # interp has just been created set fresh 1 } else { set fresh 0 } # reset interp state command before each interpretation resetInterpState $itrp $fresh g_cachefileVars g_cachefileArrayVars\ g_cachefileUntrackVars g_cachefileProcs g_cachefileAliases\ g_cachefileAliasesPassArg g_cachefileAliasesTraces\ g_cachefileRenameCmds g_cachefileCommands # reset modulefile-specific variable before each interpretation interp eval $itrp set ::ModulesCurrentCachefile "{$cachefile}" # evaluate cache file ##nagelfar ignore +4 Suspicious # char set exec_res [interp eval $itrp { set cachecontent [readCacheContent $::ModulesCurrentCachefile] if {$cachecontent eq {}} { # simply skip cache file, no exit on error here return 0 } info script $::ModulesCurrentCachefile if {[catch {eval $cachecontent} errorMsg]} { # format stack trace to report cachefile information only reportInternalBug [formatErrStackTrace $::errorInfo\ $::ModulesCurrentCachefile [list {*}[info procs] {*}[info\ commands]]] {} {Cache ERROR} return 0 } else { return 1 } }] reportDebug "exiting $cachefile (result=$exec_res)" lpopState debug_msg_prefix lpopState modulepath return $exec_res } # cache file command to record modulefile content proc modulefile-content {mod mtime header content} { set modfile [currentState modulepath]/$mod # record modulefile information in memory structures set ::g_modfileContent($modfile) [list $header $content] set ::g_fileMtime($modfile) $mtime set ::g_modfileValid($modfile) [list true {}] # gather all modulefiles/modulercs of a modulepath in a global variable # with same information structure than findModules result lappend ::g_cacheModpath([currentState modulepath]) $mod [list modulefile\ $mtime $modfile] } # cache file command to record modulerc content proc modulerc-content {modrc header content} { set modrcfile [currentState modulepath]/$modrc # record modulerc information in memory structures set ::g_modfileContent($modrcfile) [list $header $content] # gather all modulefiles/modulercs of a modulepath in a global variable # with same information structure than findModules result lappend ::g_cacheModpath([currentState modulepath]) $modrc [list modulerc] } # cache file command to record an invalid modulefile proc modulefile-invalid {mod type msg} { set modfile [currentState modulepath]/$mod # record modulefile information in memory structures set ::g_modfileValid($modfile) [list $type $msg] # also gather all invalid modulefiles of a modulepath in a global variable # with same information structure than findModules result lappend ::g_cacheModpath([currentState modulepath]) $mod [list $type $msg\ $modfile] } # gather modulepath limited access files in specific structure proc limited-access-file {mod} { lappend ::g_cacheFLimitedModpath([currentState modulepath]) $mod 1 } # gather modulepath limited access files in specific structure proc limited-access-directory {dir} { lappend ::g_cacheDLimitedModpath([currentState modulepath]) $dir 1 } # finds all module-related files matching mod in the modulepath dir by looking # into the cache file proc findModulesInCacheFile {modpath mod depthlvl fetch_mtime} { set cachefile [getModuleCacheFilename $modpath] # check if cache should be ignored if {[getConf ignore_cache]} { return [list 0 {}] } # check if a cache file is available (exist, readable and not expired) if {![info exists ::g_cachefilesAvail($cachefile)]} { if {[file readable $cachefile]} { reportDebug "cache file '$cachefile' exists and is readable" # check expiry if enabled if {[set expiry_secs [getConf cache_expiry_secs]] != 0} { set cachemtime [getFileMtime $cachefile] # cache is also considered expired if its mtime cannot be fetched set ::g_cachefilesAvail($cachefile) [expr {$cachemtime ne {} &&\ $expiry_secs > ([getState clock_seconds] - $cachemtime)}] if {!$::g_cachefilesAvail($cachefile)} { reportDebug "cache file '$cachefile' has expired" } } else { set ::g_cachefilesAvail($cachefile) 1 } } else { reportDebug "cache file '$cachefile' cannot be found or read" set ::g_cachefilesAvail($cachefile) 0 } } # return if no cache file available if {!$::g_cachefilesAvail($cachefile)} { return [list 0 {}] } # evaluate cache file if not yet done if {![info exists ::g_cachefilesSourced($cachefile)]} { set exec_res [execute-cachefile $cachefile $modpath] # keep track of already sourced cache files not to run them again set ::g_cachefilesSourced($cachefile) $exec_res } else { reportDebug "cache file '$cachefile' has already been evaluated" } # return if cache file has not been correctly sourced if {!$::g_cachefilesSourced($cachefile)} { return [list 0 {}] } # tailor cache file content to what is requested array set cache_arr $::g_cacheModpath($modpath) reportDebug "[array size cache_arr] elements are cached for '$modpath'" array set flimited_arr $::g_cacheFLimitedModpath($modpath) reportDebug "[array size flimited_arr] limited access files for '$modpath'" array set dlimited_arr $::g_cacheDLimitedModpath($modpath) reportDebug "[array size dlimited_arr] limited access dirs for '$modpath'" # filter entries unless all are requested set findall [expr {$mod in {{} *}}] defineModEqStaticProc [isIcase] [getConf extended_default] $mod if {!$findall || $depthlvl > 0} { foreach elt [array names cache_arr] { set eltroot [lindex [file split $elt] 0] set eltdepthlvl [llength [file split $elt]] set elttail [file tail $elt] set eltparent [file dirname $elt] # exclude if not matching mod pattern (which is always a root name) if {$eltroot ne {.modulerc} && !$findall && ![modEqStatic $eltroot\ match]} { unset cache_arr($elt) # also exclude if not corresponding to search depth level (or if one # modulefile has already been added for directories lying at other # depth level) } elseif {$depthlvl > 0 && $elttail ne {.modulerc} && $eltdepthlvl\ != $depthlvl && [info exists modfile_indir($eltparent)]} { unset cache_arr($elt) } else { # track a valid non-hidden modulefile has been added in parent # directory if {[string index $elttail 0] ne {.} && ![info exists\ modfile_indir($eltparent)] && [lindex $cache_arr($elt) 0] eq\ {modulefile}} { set modfile_indir($eltparent) 1 } } } } array set hidden_list {} set limited_list [list] # add limited access files and directories to result if they match query foreach elt [concat [array names flimited_arr] [array names\ dlimited_arr]] { set eltroot [lindex [file split $elt] 0] if {$eltroot eq {.modulerc} || $findall || [modEqStatic $eltroot\ match]} { set fpelt [file join $modpath $elt] lappend limited_list $fpelt # indicate file is hidden in structure that will be transmitted to # findModulesFromDirsAndFiles for no-indepth module search if {[string index [file tail $elt] 0] eq {.} && [info exists\ flimited_arr($elt)]} { set hidden_list($fpelt) 1 } } } # walk through list of matching limited access dirs and files to find # modules available to current user (transmit list of known files and dirs # to avoid file stat tests) findModulesFromDirsAndFiles $modpath $limited_list $depthlvl $fetch_mtime\ cache_arr modfile_indir hidden_list flimited_arr dlimited_arr reportDebug "found [array names cache_arr] ([array size cache_arr])" set cache_list [array get cache_arr] return [list 1 $cache_list] } # 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 {}} {cmp eq}} { 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 ##nagelfar ignore #2 Badly formed if statement 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 [expr {$from_obj in $extfrom}] set in_extto [expr {$to_obj in $extto}] # are elts the sames and are both part of or missing from extra lists # when comparing modules, ask comparison against loaded module # alternative and simplified names (modEq will also compare variants) if {($cmp eq {modeq} && ![modEq $to_obj $from_obj equal 1 3 1]) ||\ ($cmp eq {eq} && $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 proc getSimplifiedLoadedModuleList {} { set curr_mod_list {} array set curr_tag_arr {} set modpathlist [getModulePathList] foreach mod [getLoadedModulePropertyList name] { set altandsimplist [getLoadedAltAndSimplifiedName $mod] set parentmod [file dirname $mod] set simplemod $mod # simplify to parent name as long as it is found in simplified name list while {$parentmod ne {.}} { if {$parentmod in $altandsimplist} { set simplemod $parentmod set parentmod [file dirname $parentmod] } else { set parentmod . } } # add each module specification as list to correctly enclose spaces in # module name or variant name or value set simplemodvr [list $simplemod {*}[getVariantList $mod 5 1]] lappend curr_mod_list $simplemodvr # record tags applying to module in simplified version form set tag_list [getSaveTagList $mod] if {[llength $tag_list] > 0} { set curr_tag_arr($simplemodvr) $tag_list } } return [list $curr_mod_list [array get curr_tag_arr]] } # return saved collections found in user directory which corresponds to # enabled collection target if any set. extract one collection specifically # when search mode is set to exact. only compute collection name if mode is # set to name. translate collection name to __init__ if not found and # swap_by_init enabled. if no_other_target enabled, ensure no result from # other target are returned from glob search proc findCollections {{coll *} {search glob} {swap_by_init 0} {errnomatch 0}\ {checkvalid 1} {no_other_target 0}} { # initialize description with collection name set colldesc $coll if {$coll eq {}} { reportErrorAndExit [getEmptyNameMsg collection] } elseif {$coll eq {__init__}} { set collfile $coll set colldesc {} # 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 # 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. current target # is ignored if --all option is set on savelist command set colltarget [getConf collection_target] if {$colltarget ne {} && ([getState hiding_threshold] < 2 ||\ [currentState commandname] ne {savelist})} { append collfile .$colltarget # add knowledge of collection target on description append colldesc " (for target \"$colltarget\")" } } else { reportErrorAndExit {HOME not defined} } switch -- $search { glob { # glob excludes by default files starting with "." if {[catch {set clist [glob -nocomplain $collfile]} errMsg]} { reportErrorAndExit "Cannot access collection directory.\n$errMsg" } else { set res {} foreach cfile $clist { # test collection is from correct target or no target if # no_other_target is enabled set cfile_ext [string range [file extension $cfile] 1 end] if {(!$no_other_target || $cfile_ext eq [getConf\ collection_target]) && [checkValidColl $cfile]} { lappend res $cfile } } } } exact { if {$coll ne {__init__}} { # verify that file exists if {![file exists $collfile]} { if {$errnomatch} { reportErrorAndExit "Collection $colldesc cannot be found" } else { set collfile {} } # error will be raised if collection not valid } elseif {$checkvalid && ![checkValidColl $collfile\ $errnomatch]} { set collfile {} } } if {$collfile eq {} && $swap_by_init} { set collfile __init__ set colldesc {} } # return coll filename and its description for exact and name modes set res [list $collfile $colldesc] } name { set res [list $collfile $colldesc] } } return $res } proc checkValidColl {collfile {report_issue 0}} { set res 0 if {[catch { set fdata [readFile $collfile 1] # extract magic cookie (first word) set fh [string trimright [lindex [split [string range $fdata 0 32]]\ 0] #] } errMsg ]} { if {$report_issue} { reportErrorAndExit [parseAccessIssue $collfile] } } else { # collection without magic cookie are valid # check if min version requirement is met if {[string equal -length 8 $fh {#%Module}] && [string length $fh] \ > 8 && [versioncmp {5.3.0} [string range $fh 8 end]] \ < 0} { if {$report_issue} { reportErrorAndExit "Collection $collfile requires at least\ Modules version [string range $fh 8 end]" } } else { set res 1 } } return $res } # generate collection content based on provided path and module lists proc formatCollectionContent {path_list mod_list tag_arrser header {sgr 0}} { set content {} array set tag_arr $tag_arrser # 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 { # save tags associated to module (like auto-loaded tag) if {[info exists tag_arr($mod)] && [llength $tag_arr($mod)] > 0} { set opt "--tag=[join $tag_arr($mod) :] " } else { set opt {} } # no need to specifically enclose module specification if space char # used in it as $mod is a list so elements including space will be # automatically enclosed append content "$modcmd load $opt$mod" \n } # prepend header if defined and some content has been generated if {[string length $header] != 0 && [string length $content] != 0} { set content "$header\n$content" } return $content } # read given collection file and return the path and module lists it defines proc readCollectionContent {collfile colldesc} { # read file if {[catch { set fdata [split [readFile $collfile] \n] } errMsg ]} { reportErrorAndExit "Collection $colldesc cannot be read.\n$errMsg" } return [parseCollectionContent $fdata] } proc parseCollectionContent {fdata} { # init lists (maybe coll does not set mod to load) set path_list {} set mod_list {} set nuasked_list {} array set tag_arr {} # 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} { # extract collection-specific flags from module specification switch -glob -- [lindex $modarg 0] { --notuasked { set tag_list [list auto-loaded] set cleanlist [lrange $modarg 1 end] } --tag=* { set tag_list [split [string range [lindex $modarg 0] 6 end] :] set cleanlist [lrange $modarg 1 end] } default { set tag_list {} set cleanlist $modarg } } # parse module specification to distinguish between module + variant # specified and multiple modules specified on a single line set parsedlist [parseModuleSpecification 0 0 0 0 {*}$cleanlist] foreach parsed $parsedlist { set tag_arr($parsed) $tag_list } lappend mod_list {*}$parsedlist } } return [list $path_list $mod_list [array get tag_arr]] } # return specified collection content and differences compared to currently # defined environment proc getDiffBetweenCurEnvAndColl {collfile colldesc} { # read specific __init__ collection from __MODULES_LMINIT env var if {$collfile eq {__init__}} { lassign [parseCollectionContent [getLoadedModulePropertyList init]]\ coll_path_list coll_mod_list coll_tag_arrser } else { lassign [readCollectionContent $collfile $colldesc] coll_path_list\ coll_mod_list coll_tag_arrser } # build list of module tagged auto-loaded in collection array set coll_tag_arr $coll_tag_arrser set coll_nuasked_list {} foreach mod [array names coll_tag_arr] { if {{auto-loaded} in $coll_tag_arr($mod)} { lappend coll_nuasked_list $mod } } # collection should at least define a path or a mod, but initial env may be # totally empty if {$collfile ne {__init__} && [llength $coll_path_list] == 0 && [llength\ $coll_mod_list] == 0} { reportErrorAndExit "$colldesc is not a valid collection" } # load tags from loaded modules cacheCurrentModules defineModEqProc [isIcase] [getConf extended_default] # fetch what is currently loaded set curr_path_list [getModulePathList returnempty 0] # get current loaded module list set curr_mod_list [getLoadedModulePropertyList name] set curr_nuasked_list [getTaggedLoadedModuleList auto-loaded] # get current save tags of loaded modules array set curr_tag_arr [getLoadedModuleWithVariantSaveTagArrayList] # determine what module to unload to restore collection from current # situation with preservation of the load order (asking for a modeq # comparison will help to check against simplified mod name and variants) lassign [getMovementBetweenList $curr_mod_list $coll_mod_list\ $curr_nuasked_list $coll_nuasked_list modeq] mod_to_unload mod_to_load # proceed as well for modulepath lassign [getMovementBetweenList $curr_path_list $coll_path_list] \ path_to_unuse path_to_use # indicate if loaded modules that matches modules in collection have # different tags set if {[llength $mod_to_load] == 0} { # consider a not-set entry as an empty element when comparing collection # and current environment tags. compare tags as unordered lists lassign [getDiffBetweenArray curr_tag_arr coll_tag_arr 1 1] notincoll\ diff notincurr set is_tags_diff [expr {[llength $diff] > 0}] # if some module from collection are not yet loaded, consider there is a # difference } else { set is_tags_diff 1 } return [list $coll_path_list $coll_mod_list $coll_tag_arrser\ $coll_nuasked_list $mod_to_unload $mod_to_load $path_to_unuse\ $path_to_use $is_tags_diff] } proc getCollectionFromStash {stash} { if {[string match stash-* $stash]} { set coll $stash } elseif {[string is integer -strict $stash]} { # filter collection from other target (especially if no target set) set collfile [lindex [lsort -decreasing [findCollections stash-* glob\ 0 0 1 1]] $stash] if {$collfile eq {}} { knerror "Invalid stash index '$stash'" } # extract collection name (without path and target extension) set coll [file rootname [file tail $collfile]] } else { knerror "Invalid stash collection name '$stash'" } return $coll } proc cmdModuleList {show_oneperline show_mtime search_match args} { set json [isStateEqual report_format json] # load tags from loaded modules cacheCurrentModules if {[llength $args] > 0} { defineModEqProc [isIcase] [getConf extended_default] # match passed name against any part of loaded module names set mtest [expr {{contains} in $search_match ? {matchin} : {match}}] set search_queries $args # prepare header message which depend if search is performed set loadedmsg {Currently Loaded Matching Modulefiles} } else { set search_queries {} set loadedmsg {Currently Loaded Modulefiles} } # filter-out hidden loaded modules unless all module should be seen if {[getState hiding_threshold] > 1} { set loadedmodlist [getLoadedModulePropertyList name] } else { set loadedmodlist [list] foreach mod [getLoadedModulePropertyList name] { if {![isModuleTagged $mod hidden-loaded 1]} { lappend loadedmodlist $mod } } } # same header msg if no module loaded at all whether search is made or not set noloadedmsg [expr {[llength $loadedmodlist] == 0 ? {No Modulefiles\ Currently Loaded.} : {No Matching Modulefiles Currently Loaded.}}] # filter loaded modules not matching any of the mod spec passed if {[llength $args] > 0} { set matchlist [list] foreach mod $loadedmodlist { foreach pattern $args { # compare pattern against loaded module, its variant set and its # alternative names if {[modEq $pattern $mod $mtest 1 2 1 0 *]} { lappend matchlist $mod break } } } set loadedmodlist $matchlist } if {[llength $loadedmodlist] == 0} { if {!$json && [isEltInReport header]} { report $noloadedmsg } } else { # build mod_list array with loaded modules foreach mod $loadedmodlist { set modfile [getModulefileFromLoadedModule $mod] set mtime [expr {$show_mtime && [file exists $modfile] ?\ [getFileMtime $modfile] : {}}] set mod_list($mod) [list modulefile $mtime $modfile] # fetch symbols from loaded environment information set modname [file dirname $mod] set sym_list {} foreach altname [getLoadedAltname $mod 0 sym] { # skip non-symbol entry if {$altname ne $modname} { lappend sym_list [file tail $altname] } } set ::g_symbolHash($mod) [lsort -dictionary $sym_list] } set one_per_line [expr {$show_mtime || $show_oneperline}] set show_idx [expr {!$show_mtime && [isEltInReport idx]}] set header [expr {!$json && [isEltInReport header] ? $loadedmsg :\ {noheader}}] set theader_cols [list hi Package 39 Versions 19 {Last mod.} 19] reportModules $search_queries $header {} terse $show_mtime $show_idx\ $one_per_line $theader_cols loaded $loadedmodlist # display output key if {!$show_mtime && !$json && [isEltInReport key]} { displayKey } } } proc cmdModuleDisplay {args} { lappendState mode display set first_report 1 foreach mod $args { lassign [getPathToModule $mod] modfile modname modnamevr 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 modnamevr $mod displaySeparatorLine } } lpopState mode } proc cmdModulePaths {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 [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 modnamevr # 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} { lassign [getPathToModule $mod] modfile modname modnamevr # 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 {}}} { # disable error reporting to avoid modulefile errors # to mix with valid search results inhibitErrorReport set json [isStateEqual report_format json] set icase [isIcase] defineModEqProc $icase [getConf extended_default] lappend searchmod rc_defs_included if {$mod eq {}} { lappend searchmod wild } set foundmod 0 lappendState mode 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 { if {[isModuleTagged $elt forbidden]} { # register any error occurring on element matching search if {[modEq $mod $elt]} { set err_list($elt) [list accesserr [getForbiddenMsg\ $elt]] } } else { 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 { if {[isModuleTagged $elt forbidden]} { # register any error occurring on element matching search if {[modEq $mod $elt]} { set err_list($elt) [list accesserr [getForbiddenMsg\ $elt]] } } else { set interp_list($elt) [lindex $mod_list($elt) 2] set full_list($elt) 1 } } alias { # 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 modnamevr 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] } } } } version { # report error of version target if matching query set elt_target [getArrayKey mod_list [lindex $mod_list($elt)\ 1] $icase] if {[info exists mod_list($elt_target)] && [lindex\ $mod_list($elt_target) 0] in [list invalid accesserr] &&\ [modEq $mod $elt]} { set err_list($elt_target) $mod_list($elt_target) } elseif {![info exists mod_list($elt_target)]} { set extra_search($elt_target) [list $dir [modEq $mod $elt]] } } invalid - accesserr { # register any error occurring 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 modnamevr 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 {} ##nagelfar ignore Suspicious variable name execute-modulefile $interp_list($elt) $elt $elt $elt 0 # 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 1] } 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 0 $display_list } } lpopState mode setState inhibit_errreport 0 # 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] { reportIssue {*}$err_list($elt) } } } proc cmdModuleSwitch {uasked tag_list 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)" # extend requirement recording inhibition to switch subcontext set inhibit_req_rec [expr {[currentState inhibit_req_record] ==\ [currentState evalid]}] # 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-[depthState modulename] if {$inhibit_req_rec} { lappendState inhibit_req_record [currentState evalid] } # enable unload of sticky mod if stickiness is preserved on swapped-on mod # need to resolve swapped-off module here to get stickiness details lassign [getPathToModule $old {} 0 $unload_match] modfile oldmod oldmodvr set sticky_reload [isStickinessReloading $oldmodvr [list $new]] set supersticky_reload [isStickinessReloading $oldmodvr [list $new]\ super-sticky] # do not set sticky or supersticky reload states if swap-on module cannot # be found if {$supersticky_reload || $sticky_reload} { lassign [getPathToModule $new] newmodfile newmod newmodvr if {$newmodfile eq {}} { set sticky_reload 0 set supersticky_reload 0 } } if {$sticky_reload} { lappendState reloading_sticky $oldmod } if {$supersticky_reload} { lappendState reloading_supersticky $oldmod } ##nagelfar implicitvarcmd {cmdModuleUnload swunload *} oldhidden olduasked\ oldmsgrecid deprelist depreisuasked deprevr depreextratag set ret [cmdModuleUnload swunload $unload_match 1 0 0 0 $old] if {$sticky_reload} { lpopState reloading_sticky } if {$supersticky_reload} { lpopState reloading_supersticky } # register modulefile to unload as conflict if an unload module is # mentioned 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 newmodvr 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} { if {[info exists depreisuasked]} { set undepreisuasked $depreisuasked set undeprevr $deprevr set undepreextratag $depreextratag } ##nagelfar implicitvarcmd {cmdModuleLoad swload *} newhidden newmsgrecid cmdModuleLoad swload $uasked 0 0 $tag_list $new # merge depre info of unload and load phases if {[info exists undepreisuasked]} { set depreisuasked [list {*}$undepreisuasked {*}$depreisuasked] set deprevr [list {*}$undeprevr {*}$deprevr] set depreextratag [list {*}$undepreextratag {*}$depreextratag] } 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 $depreisuasked $deprevr\ $depreextratag 1 {Reload of dependent _MOD_ failed} depre } # report a summary of automated evaluations if no error reportModuleEval } else { # initialize dummy load phase msg rec id to query designation set newmsgrecid {} } # report all recorded sumup messages for this evaluation unless both old # and new modules are set hidden, old was auto loaded and this switch is # done by a modfile reportMsgRecord "Switching from [getModuleDesignation $oldmsgrecid {} 2]\ to [getModuleDesignation $newmsgrecid $new 2]" [expr {$oldhidden &&\ !$olduasked && $newhidden && !$uasked}] popMsgRecordId if {$inhibit_req_rec} { lpopState inhibit_req_record } # register modulefile to load as prereq when called from modulefile if {!$uasked && !$ret && $argnew ne {}} { prereqAnyModfileCmd 0 0 $argnew } } proc cmdModuleSave {{coll default}} { 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 [getLoadedModuleWithVariantList] set curr_tag_arrser [getLoadedModuleWithVariantSaveTagArrayList] } else { lassign [getSimplifiedLoadedModuleList] curr_mod_list curr_tag_arrser } # generate collection content with header indicating oldest Modules version # compatible with collection syntax set coll_header [expr {[llength $curr_tag_arrser] > 0 ? {#%Module5.1} :\ {}}] set save [formatCollectionContent [getModulePathList returnempty 0]\ $curr_mod_list $curr_tag_arrser $coll_header] if { [string length $save] == 0} { reportErrorAndExit {Nothing to save in a collection} } # get corresponding filename and its directory lassign [findCollections $coll name] collfile colldesc set colldir [file dirname $collfile] if {![file exists $colldir]} { reportDebug "Creating $colldir" if {[catch {file mkdir $colldir} errMsg]} { reportErrorAndExit "Collection directory cannot be created.\n$errMsg" } } 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 {args} { # distinguish between zero and one argument provided if {[llength $args] == 0} { set arg_provided 0 set coll default } else { set arg_provided 1 set coll [lindex $args 0] } # get corresponding collection, raise error if it does not exist unless # if no collection name has been provided or if __init__ lassign [findCollections $coll exact [expr {!$arg_provided}]\ $arg_provided] collfile colldesc # forcibly enable implicit_default to restore colls saved in this mode setConf implicit_default 1 # fetch collection content and differences compared current environment lassign [getDiffBetweenCurEnvAndColl $collfile $colldesc] coll_path_list\ coll_mod_list coll_tag_arrser coll_nuasked_list mod_to_unload\ mod_to_load path_to_unuse path_to_use is_tags_diff array set coll_tag_arr $coll_tag_arrser # create an eval id to track successful/failed module evaluations pushMsgRecordId restore-$coll-[depthState modulename] 0 # unload modules one by one (no dependency auto unload) foreach mod [lreverse $mod_to_unload] { # test stickiness over full module name version variant designation if {[set vr [getVariantList $mod 1]] ne {}} { lassign [parseModuleSpecification 0 0 0 0 $mod {*}$vr] modvr } else { set modvr $mod } # sticky modules can be unloaded when restoring collection lappendState unloading_sticky $mod if {[set supersticky_reload [isStickinessReloading $modvr $mod_to_load\ super-sticky]]} { lappendState reloading_supersticky $mod } cmdModuleUnload unload match 0 0 0 0 $mod lpopState unloading_sticky if {$supersticky_reload} { lpopState reloading_supersticky } } # unuse paths if {[llength $path_to_unuse] > 0} { cmdModuleUnuse load {*}[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] set curr_mod_list [getLoadedModulePropertyList name] set curr_nuasked_list [getTaggedLoadedModuleList auto-loaded] # update tags sets on the modules already loaded at correct position # remove extra tags that are not defined in collection foreach modvr [getLoadedModuleWithVariantList] { if {[info exists coll_tag_arr($modvr)]} { set tag_list $coll_tag_arr($modvr) } else { set tag_list {} } # indicate if module has been asked by user cmdModuleTag 1 [expr {![isModuleTagged $modvr auto-loaded 1]}]\ $tag_list $modvr } # determine what module to load to restore collection from current # situation with preservation of the load order # list of alternative and simplified names for loaded modules has been # gathered and cached during the previous getMovementBetweenList call on # modules, so here the getMovementBetweenList call will correctly get these # alternative names for module comparison even if no modulepath is left set lassign [getMovementBetweenList $curr_mod_list $coll_mod_list\ $curr_nuasked_list $coll_nuasked_list modeq] mod_to_unload mod_to_load # 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 cmdModuleUse load append {*}$path_to_use } # load modules one by one with user asked state preserved foreach mod $mod_to_load { cmdModuleLoad load [expr {$mod ni $coll_nuasked_list}] 0 0\ $coll_tag_arr($mod) $mod } popMsgRecordId 0 } proc cmdModuleSaverm {{coll default}} { # 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 corresponding collection, raise error if it does not exist, but do # not check if collection is valid lassign [findCollections $coll exact 0 1 0] collfile colldesc # attempt to delete specified collection if {[catch { file delete $collfile } errMsg ]} { reportErrorAndExit "Collection $colldesc cannot be removed.\n$errMsg" } } proc cmdModuleSaveshow {args} { # distinguish between zero and one argument provided if {[llength $args] == 0} { set arg_provided 0 set coll default } else { set arg_provided 1 set coll [lindex $args 0] } # get corresponding collection, raise error if it does not exist unless # if no collection name has been provided or if __init__ lassign [findCollections $coll exact [expr {!$arg_provided}]\ $arg_provided] collfile colldesc # read specific __init__ collection from __MODULES_LMINIT env var if {$collfile eq {__init__}} { lassign [parseCollectionContent [getLoadedModulePropertyList init]]\ coll_path_list coll_mod_list coll_tag_arrser set collfile {initial environment} set coll __init__ } else { lassign [readCollectionContent $collfile $colldesc] coll_path_list\ coll_mod_list coll_tag_arrser } # collection should at least define a path or a mod, but initial env may be # totally empty if {$coll ne {__init__} && [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_tag_arrser {} 1] displaySeparatorLine } proc cmdModuleSavelist {show_oneperline show_mtime search_match args} { # if a target is set, only list collection matching this target (means # having target as suffix in their name) unless if --all option is set set colltarget [getConf collection_target] if {$colltarget ne {} && [getState hiding_threshold] < 2} { set suffix .$colltarget set targetdesc " (for target \"$colltarget\")" } else { set suffix {} set targetdesc {} } set json [isStateEqual report_format json] reportDebug "list collections$targetdesc" # if only stash collection are expected, start result index at 0, sort # results in reverse order (latest first) and ensure only collection from # current target (and no-target if none set) are returned. if {[getCallingProcName] eq {cmdModuleStashlist}} { set start_idx 0 set sort_opts [list -dictionary -decreasing] set find_no_other_target 1 set typedesc stash # no icase match as stash collections are only lowercases set icase 0 } else { set start_idx 1 set sort_opts [list -dictionary] set find_no_other_target 0 set typedesc named set icase [isIcase] } if {[llength $args] > 0} { defineModEqProc $icase 0 # match passed name against any part of collection names set mtest [expr {{contains} in $search_match ? {matchin} : {match}}] } # prepare header message which depend if search is performed (no search # considered if listing stash collections) if {[llength $args] > 0 && $typedesc ne {stash}} { set collmsg "Matching $typedesc collection list$targetdesc:" } else { set collmsg "[string totitle $typedesc] collection list$targetdesc:" } foreach collfile [findCollections * glob 0 0 1 $find_no_other_target] { # remove target suffix from names to display regsub $suffix$ [file tail $collfile] {} coll # filter stash collections unless called by stashlist or --all opt set if {$typedesc ne {named} || ![regexp {stash-\d+} $coll] || [getState\ hiding_threshold] >= 2} { set coll_arr($coll) $collfile } } # same header msg if no collection at all whether search is made or not if {![array exists coll_arr] || $typedesc eq {stash}} { set nocollmsg "No $typedesc collection$targetdesc." } else { set nocollmsg "No matching $typedesc collection$targetdesc." } # filter collection not matching any of the passed specification if {[llength $args] > 0} { set matchlist [list] foreach coll [array names coll_arr] { set match 0 foreach pattern $args { # compare pattern against collections using comparison module proc # useful for suffix/prefix/icase checks, disabling module-specific # checks (variants, alternative names, etc) if {[modEq $pattern $coll $mtest 0 0 0 0 *]} { set match 1 break } } if {!$match} { unset coll_arr($coll) } } } if {[array size coll_arr] == 0} { if {!$json} { report $nocollmsg } } else { if {!$json} { if {$show_mtime} { displayTableHeader hi Collection 59 {Last mod.} 19 } report $collmsg } set display_list {} set len_list {} set max_len 0 set one_per_line [expr {$show_mtime || $show_oneperline}] set show_idx [expr {!$one_per_line}] # prepare query to highlight set himatchmap [prepareMapToHightlightSubstr {*}$args] foreach coll [lsort {*}$sort_opts [array names coll_arr]] { if {$json} { lappend display_list [formatListEltToJsonDisplay $coll target s\ $colltarget 1 pathname s $coll_arr($coll) 1] # no need to test coll consistency as findCollections does not return # collection whose name starts with "." } else { set collsgr [sgr {} $coll $himatchmap] if {$show_mtime} { set filetime [clock format [getFileMtime $coll_arr($coll)]\ -format {%Y/%m/%d %H:%M:%S}] lappend display_list [format %-60s%19s $collsgr $filetime] } else { lappend display_list $collsgr lappend len_list [set len [string length $coll]] if {$len > $max_len} { set max_len $len } } } } displayElementList noheader {} {} $one_per_line $show_idx $start_idx\ $display_list $len_list $max_len } } proc cmdModuleSource {mode args} { foreach mod $args { set rawarg [getRawArgumentFromVersSpec $mod] if {$mod eq {}} { reportErrorAndExit {File name empty} # first check if raw specification is an existing file } elseif {[file exists [set absfpath [getAbsolutePath $rawarg]]]} { set modfile $absfpath set modname $absfpath set modnamevr $absfpath # unset module specification not to confuse specific char in file # path (like '+') with variant specification unsetModuleVersSpec $mod set mod $absfpath # if not a path specification, try to resolve a modulefile } elseif {![isModuleFullPath $rawarg]} { lassign [getPathToModule $mod] modfile modname modnamevr # stop if no module found, issue has been reported by getPathToModule if {$modfile eq {}} { break } } else { reportErrorAndExit "File $rawarg does not exist" } ##nagelfar ignore Found constant lappendState mode $mode # sourced file must also have a magic cookie set at their start ##nagelfar ignore Suspicious variable name execute-modulefile $modfile $modname $modnamevr $mod 0 0 ##nagelfar ignore Found constant lpopState mode } } proc cmdModuleLoad {context uasked tryload loadany tag_list args} { reportDebug "loading $args (context=$context, uasked=$uasked,\ tryload=$tryload, loadany=$loadany)" set ret 0 set loadok 0 lappendState mode load foreach mod $args { # stop when first module in list is loaded if any mode enabled if {$loadok && $loadany} { break } # 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 } upvar newhidden hidden upvar newmsgrecid msgrecid } # loading module is visible by default set hidden 0 # error if module not found or forbidden set notfounderr [expr {!$tryload}] # record evaluation attempt on specified module name registerModuleEvalAttempt $context $mod lassign [getPathToModule $mod {} $notfounderr] modfile modname modnamevr # set a unique id to record messages related to this evaluation. set msgrecid load-$modnamevr-[depthState modulename] # go to next module to load if not matching module found if {$modfile eq {}} { set ret $notfounderr continue } if {[isModuleEvalFailed load $modnamevr]} { reportDebug "$modnamevr ($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 depreisuasked depreisuasked upvar deprevr deprevr upvar depreextratag depreextratag # transmit loaded mod name for switch report summary uplevel 1 set new "{$modnamevr}" } # register record message unique id (now we know mod will be evaluated) pushMsgRecordId $msgrecid # record evaluation attempt on actual module name registerModuleEvalAttempt $context $modnamevr 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 $modnamevr] if {$loadedmodname ne {}} { set modname $loadedmodname set modnamevr $modname if {[set vr [getVariantList $modname 1]] ne {}} { append modnamevr " $vr" } } # record module title (with the variant specified on load call, and no # tag list) prior module evaluation to get this title ready in case of # eval error registerModuleDesignation $msgrecid $modname [getVariantList $mod 7 0\ 1] {} pushSettings if {[set errCode [catch { if {[set isloaded [isModuleLoaded $modname]] || [set isloading\ [isModuleLoading $modname]]} { reportDebug "$modname ($modfile) already loaded/loading" # stop if same mod is loaded but with a different set of variants if {$modname ne $modnamevr && (($isloaded && [getLoadedMatchingName $modnamevr] eq {}) || ([info exists\ isloading] && $isloading && [getLoadedMatchingName $modnamevr\ {} 1] eq {}))} { set errlocalreport 1 knerror [getModWithAltVrIsLoadedMsg $modname] } else { # apply missing tag to loaded module set rettag [cmdModuleTag 0 $uasked $tag_list $modname] # report module is already loaded if verbose2 or higher level # and no new tag set if {$isloaded && $rettag != 2 && [isVerbosityLevel verbose2]} { reportInfo "Module '$modname' is already loaded" registerModuleDesignation $msgrecid $modname\ [getVariantList $modname 7] [getExportTagList $modname] reportMsgRecord "Loading [getModuleDesignation $msgrecid {}\ 2]" } # exit treatment but no need to restore settings set loadok 1 continue } } # register altname of modname prior any conflict check setLoadedAltname $modname {*}[getAllModuleResolvedName $modname 1\ $mod] if {[getConf auto_handling]} { # get loaded modules holding a requirement on modname and able to # be reloaded set deprelist [getUnmetDependentLoadedModuleList $modnamevr] 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} { lassign [reloadModuleListUnloadPhase deprelist [getState\ force] {Unload of dependent _MOD_ failed} depun]\ depreisuasked deprevr depreextratag if {[info exists swprocessing]} { if {[info exists swdeprelist]} { set swdeprelist [list {*}$deprelist {*}$swdeprelist] } else { set swdeprelist $deprelist } } } } # record additional tags passed through --tag option prior mod eval # to make them known within evaluation if {[llength $tag_list] > 0} { # record tags set with --tag as extra tag excluding tags relative # to the way module is loaded (auto, keep) lassign [getDiffBetweenList $tag_list [list auto-loaded\ keep-loaded]] extratag_list setModuleTag $modname {*}$tag_list if {[llength $extratag_list] > 0} { setModuleExtraTag $modname {*}$extratag_list } if {$modnamevr ne {} && $modname ne $modnamevr} { setModuleTag $modnamevr {*}$tag_list if {[llength $extratag_list] > 0} { setModuleExtraTag $modnamevr {*}$extratag_list } } } if {[execute-modulefile $modfile $modname modnamevr $mod]} { break } # register this evaluation on the main one that triggered it (after # load evaluation to report correct order with other evaluations) registerModuleEval $context $msgrecid # 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 [isModuleEvaluated conun $modnamevr {*}$modconlist] if {![set retiseval [isModuleEvaluated any $modnamevr\ {*}$modconlist]] || [currentState msgrecordid] ne [topState\ msgrecordid] || !$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 || [getState force] ?\ [getConIsLoadedMsg $moddecconlist [is-loading $modconlist]] :\ [getErrConflictMsg $moddecconlist]}] } # still proceed if force mode enabled if {[getState force] && $doescon} { defineModEqProc [isIcase] [getConf extended_default] # report warning if not already done set report_con 1 if {[info exists ::report_conflict($msgrecid)]} { # check if conflict has not been already reported with an # alternative name foreach modcon $modconlist { foreach reportmod $::report_conflict($msgrecid) { if {[modEq $reportmod $modcon eqstart 1 2 1]} { set report_con 0 break } } if {!$report_con} { break } } if {$report_con} { foreach moddeccon $moddecconlist { foreach reportmod $::report_conflict($msgrecid) { if {[modEq $reportmod $moddeccon eqstart]} { set report_con 0 break } } if {!$report_con} { 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 } } # loading visibility depends on hidden-loaded tag set hidden [isModuleTagged $modnamevr hidden-loaded 1] append-path LOADEDMODULES $modname # allow duplicate modfile entries for virtual modules append-path --duplicates _LMFILES_ $modfile # update cache arrays setLoadedModule $modname $modfile $uasked $modnamevr [expr {$modname\ in [getState refresh_qualified]}] # register declared source-sh in environment if {[set modsrcsh [getLoadedSourceSh $modname 1]] ne {}} { append-path __MODULES_LMSOURCESH $modsrcsh } # register declared conflict in environment if {[set modcon [getLoadedConflict $modname 1]] ne {}} { append-path __MODULES_LMCONFLICT $modcon } # declare the prereq of this module if {[set modpre [getLoadedPrereq $modname 1]] ne {}} { append-path __MODULES_LMPREREQ $modpre } # declare the alternative names of this module if {[set modalt [getLoadedAltname $modname 1]] ne {}} { append-path __MODULES_LMALTNAME $modalt } # declare the variant of this module if {[set modvrspec [getLoadedVariant $modname 1]] ne {}} { append-path __MODULES_LMVARIANT $modvrspec } # declare the tags of this module if {[set modtag [getExportTagList $modnamevr 1]] ne {}} { append-path __MODULES_LMTAG $modtag } if {[set modtag [getExtraTagList $modnamevr 1]] ne {}} { append-path __MODULES_LMEXTRATAG $modtag } # declare module qualified for refresh evaluation if {[isModuleRefreshQualified $modname]} { append-path __MODULES_LMREFRESH $modname } # 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 $depreisuasked $deprevr\ $depreextratag [getState force] {Reload of dependent _MOD_\ failed} depre } # record module title (name, variants and tags) registerModuleDesignation $msgrecid $modname [getVariantList\ $modname 7] [getExportTagList $modname] # consider evaluation hidden if hidden loaded module is auto loaded # and no specific messages are recorded for this evaluation if {$hidden && !$uasked && ![isMsgRecorded]} { registerModuleEvalHidden $context $msgrecid } # report a summary of automated evaluations if no error reportModuleEval } errMsg]] != 0 && $errCode != 4} { # in case of error report module info even if set hidden set hidden 0 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 [getModuleDesignation\ $msgrecid] failed" 1 } # rollback settings if some evaluation went wrong set ret 1 restoreSettings # remove from successfully evaluated module list registerModuleEval $context $msgrecid $modnamevr load unset -nocomplain errlocalreport } popSettings # report all recorded messages for this evaluation except if module were # already loaded if {$errCode != 4} { reportMsgRecord "Loading [getModuleDesignation $msgrecid {} 2]"\ [expr {$hidden && !$uasked}] } popMsgRecordId if {$errCode == 0} { set loadok 1 } } lpopState mode # raise error if no module has been loaded or has produced an error during # its load attempt in case of top-level load-any sub-command if {!$ret && !$loadok && $context eq {load} && $loadany} { knerror "No module has been loaded" } 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 lappendState mode 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 } upvar oldhidden hidden upvar olduasked uasked upvar oldmsgrecid msgrecid } # unloading module is visible by default set hidden 0 set uasked 1 # record evaluation attempt on specified module name registerModuleEvalAttempt $context $mod # resolve by also looking at matching loaded module and update mod # specification to fully match obtained loaded module # enable report_issue flag to report empty module name issue lassign [getPathToModule $mod {} 1 $match] modfile modname\ modnamevr errkind # set a unique id to record messages related to this evaluation. set msgrecid unload-$modnamevr-[depthState modulename] # record module title (with the variant specified on unload call, and no # tag list) prior module evaluation to get this title ready in case of # eval error registerModuleDesignation $msgrecid $modname [getVariantList $modnamevr\ 7 0 1] {} # 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 depreisuasked depreisuasked upvar deprevr deprevr upvar depreextratag depreextratag # transmit unloaded mod name for switch report summary uplevel 1 set old "{$modnamevr}" } if {$modfile eq {}} { # no error return if module is not loaded if {$errkind eq {notloaded}} { reportDebug "$modname is not loaded" # report module is not loaded if verbose2 or higher level if {[isVerbosityLevel verbose2]} { pushMsgRecordId $msgrecid reportInfo "Module '$modname' is not loaded" reportMsgRecord "Unloading [getModuleDesignation $msgrecid {}\ 2]" } } else { # return error code in case of empty module name 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 $modnamevr]} { reportDebug "$modnamevr ($modfile) unload was already tried and\ failed" # nullify this evaluation attempt to avoid duplicate issue report unregisterModuleEvalAttempt $context $mod continue } # register record message unique id (now we know mod will be evaluated) pushMsgRecordId $msgrecid # record evaluation attempt on actual module name registerModuleEvalAttempt $context $modnamevr registerModuleEvalAttempt $context $modfile # record module title (name, variants and tags) registerModuleDesignation $msgrecid $modname [getVariantList $modname\ 7] [getExportTagList $modname] 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 ##nagelfar ignore Found constant if {([getState force] || $force) && !$onlyndep} { # in case unload is called for a DepRe mechanism do not warn # about prereq violation enforced as it is due to the dependent # module which is already in a violation state # warn in case of a purge if {$auto || !$force || [currentState commandname] eq\ {purge}} { 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 {[isModuleEvaluated any $modnamevr\ {*}$prereq_list] ? [getDepLoadedMsg $prereq_list] :\ [getErrPrereqMsg $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 [list {*}$depunlist $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 optionally dependent or in # conflict with modname, DepUn or UReqUn modules + modules # dependent of a module part of this DepRe batch) set deprelist [getDependentLoadedModuleList [list {*}$urequnlist\ {*}$depunlist $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 [list\ {*}$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} { ##nagelfar ignore +2 Found constant lassign [reloadModuleListUnloadPhase deprelist [getState\ force] {Unload of dependent _MOD_ failed} depun]\ depreisuasked deprevr depreextratag } # DepUn modules unload prior main mod unload if {[llength $depunlist] > 0} { foreach unmod [lreverse $depunlist] { ##nagelfar ignore Found constant if {[cmdModuleUnload depun match 0 0 0 0 $unmod]} { # stop if one unload fails unless force mode enabled set errMsg "Unload of dependent [getModuleDesignation\ loaded $unmod] failed" ##nagelfar ignore Found constant if {[getState force] || $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 $msgrecid # no need to update modnamevr and tags after evaluation as these # information were already complete in persistent environment ##nagelfar ignore Suspicious variable name if {[execute-modulefile $modfile $modname $modnamevr $mod 0 0]} { break } # unloading visibility depends on hidden-loaded tag set hidden [isModuleTagged $modname hidden-loaded 1] # module was asked by user if tagged loaded instead of auto-loaded set uasked [isModuleTagged $modname loaded 1] # unset module from list of loaded modules qualified for refresh eval if {[isModuleRefreshQualified $modname]} { remove-path __MODULES_LMREFRESH $modname } # 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 [getLoadedModulePropertyList name 0]\ $modname] remove-path LOADEDMODULES $modname remove-path --index _LMFILES_ $lmidx # update cache arrays unsetLoadedModule $modname $modfile # unregister declared source-sh if {[set modsrcsh [getLoadedSourceSh $modname 1]] ne {}} { remove-path __MODULES_LMSOURCESH $modsrcsh } unsetLoadedSourceSh $modname # unregister declared conflict if {[set modcon [getLoadedConflict $modname 1]] ne {}} { remove-path __MODULES_LMCONFLICT $modcon } unsetLoadedConflict $modname # unset prereq declared for this module if {[llength [set modpre [getLoadedPrereq $modname]]] > 0} { remove-path __MODULES_LMPREREQ [getLoadedPrereq $modname 1] } unsetLoadedPrereq $modname # unset alternative names declared for this module if {[llength [set modalt [getLoadedAltname $modname]]] >0} { remove-path __MODULES_LMALTNAME [getLoadedAltname $modname 1] } unsetLoadedAltname $modname # unset variant declared for this module if {[llength [set modvrspec [getLoadedVariant $modname]]] > 0} { remove-path __MODULES_LMVARIANT [getLoadedVariant $modname 1] } unsetLoadedVariant $modname # unset tags declared for this module if {[set modtag [getExportTagList $modname 1]] ne {}} { remove-path __MODULES_LMTAG $modtag # also remove the auto-loaded and keep-loaded tags from # in-memory knowledge not to re-apply them if module is reloaded # in other conditions unsetModuleTag $modname auto-loaded keep-loaded if {$modnamevr ne {} && $modname ne $modnamevr} { unsetModuleTag $modnamevr auto-loaded keep-loaded } } if {[set modtag [getExtraTagList $modname 1]] ne {}} { remove-path __MODULES_LMEXTRATAG $modtag # also remove extra tags from in-memory knowledge not re-apply # them if module is reloaded in other conditions set extratag_list [getExtraTagList $modname] unsetModuleTag $modname {*}$extratag_list unsetModuleExtraTag $modname {*}$extratag_list if {$modnamevr ne {} && $modname ne $modnamevr} { unsetModuleTag $modnamevr {*}$extratag_list unsetModuleExtraTag $modnamevr {*}$extratag_list } } 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] ##nagelfar ignore Found constant 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\ [getModuleDesignation loaded $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]} { ##nagelfar ignore +2 Found constant reloadModuleListLoadPhase deprelist $depreisuasked $deprevr\ $depreextratag [getState force] {Reload of dependent _MOD_\ failed} depre } } # consider evaluation hidden if hidden loaded module was auto loaded # and no specific messages are recorded for this evaluation if {$hidden && !$uasked && ![isMsgRecorded]} { registerModuleEvalHidden $context $msgrecid } # report a summary of automated evaluations if no error reportModuleEval } errMsg]] != 0 && $errCode != 4} { # in case of error report module info even if set hidden set hidden 0 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 [getModuleDesignation loaded\ $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 $msgrecid $modnamevr unload } unset -nocomplain errlocalreport errharmless } popSettings # report all recorded messages for this evaluation (hide evaluation if # loaded mod is set hidden, has been automatically loaded and unloaded) reportMsgRecord "Unloading [getModuleDesignation $msgrecid {} 2]" [expr\ {$hidden && !$uasked && [depthState evalid] != 1}] popMsgRecordId } lpopState mode return $ret } proc cmdModulePurge {} { # create an eval id to track successful/failed module evaluations pushMsgRecordId purge-[depthState modulename] 0 # unload one by one to ensure same behavior whatever auto_handling state # force it to handle loaded modules in violation state # remove dependent modules if force mode enabled set onlyndep [expr {![getState force]}] cmdModuleUnload unload match 0 1 0 $onlyndep {*}[lreverse\ [getLoadedModulePropertyList name]] popMsgRecordId 0 } proc cmdModuleReload {args} { # reload all loaded modules if no module list passed if {[llength $args] == 0} { set lmlist [getLoadedModulePropertyList name] } else { set lmlist $args } reportDebug "reloading $lmlist" # create an eval id to track successful/failed module evaluations pushMsgRecordId reload-[depthState modulename] 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 lassign [reloadModuleListUnloadPhase lmlist] isuasked vr extratag reloadModuleListLoadPhase lmlist $isuasked $vr $extratag } 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 {} } setState inhibit_errreport 0 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 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 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_cols [list hi Package/Alias 39 Versions 19 {Last mod.} 19] } else { set one_per_line 0 set hstyle sepline set theader_cols {} } # set a default filter (do not print dirs with no sym) if none set if {$show_filter eq {}} { set show_filter noplaindir } # elements to include in output set report_modulepath [isEltInReport modulepath] # consolidate search filters lappend search_filter $search_match wild set search_rc_filter $search_filter lappend search_rc_filter rc_alias_only # disable error reporting to avoid modulefile errors # to mix with avail results inhibitErrorReport foreach mod $args { set search_queries [list $mod] array unset mod_list # look if aliases have been defined in the global or user-specific # modulerc and display them if any in a dedicated list array set mod_list [getModules {} $mod $show_mtime $search_rc_filter\ $show_filter] if {$report_modulepath} { reportModules $search_queries {global/user modulerc} hi $hstyle\ $show_mtime 0 $one_per_line $theader_cols hidden-loaded } foreach dir [getModulePathList exiterronundef] { if {$report_modulepath} { array unset mod_list # get module list (process full dir content and do not exit when # err is raised from a modulerc) array set mod_list [getModules $dir $mod $show_mtime\ $search_filter $show_filter] reportModules $search_queries $dir mp $hstyle $show_mtime 0\ $one_per_line $theader_cols hidden-loaded } else { # add result if not already added from an upper priority modpath foreach {elt props} [getModules $dir $mod $show_mtime\ $search_filter $show_filter] { if {![info exists mod_list($elt)]} { set mod_list($elt) $props } } } } # no report by modulepath, mix all aggregated results if {!$report_modulepath} { reportModules $search_queries noheader {} {} $show_mtime 0\ $one_per_line $theader_cols hidden-loaded } } # display output key if {!$show_mtime && ![isStateEqual report_format json] && [isEltInReport\ key]} { displayKey } setState inhibit_errreport 0 } proc runModuleUse {cmd mode pos args} { if {$args eq {}} { showModulePath } else { if {$pos eq {remove}} { # get current module path list set modpathlist [getModulePathList returnempty 0 0] } foreach path $args { switch -glob -- $path { --remove-on-unload - --append-on-unload - --prepend-on-unload -\ --noop-on-unload { if {$cmd ne {unuse}} { knerror "Invalid option '$path'" } else { lappend pathlist $path } } -* { knerror "Invalid option '$path'" } {} { reportError [getEmptyNameMsg directory] } $* { lappend pathlist $path } default { if {$pos eq {remove}} { if {$path in $modpathlist} { lappend pathlist $path # 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 } elseif {[set abspath [getAbsolutePath $path]] in\ $modpathlist} { lappend pathlist $abspath # even if not found, transmit this path to remove-path in # case several path elements have been joined as one string } else { lappend pathlist $path } } else { # transform given path in an absolute path to avoid # dependency to the current work directory. except if this # path starts with a variable reference lappend pathlist [getAbsolutePath $path] } } } } # added directory may not exist at this time # pass all paths specified at once to append-path/prepend-path if {[info exists pathlist]} { set optlist [list] # define path command to call set pathcmd [expr {$pos eq {remove} ? {unload-path} : {add-path}}] # by-pass any reference counter in case use is called from top level # not to increase reference counter if paths are already defined if {[isTopEvaluation]} { lappend optlist --ignore-refcount } if {[isTopEvaluation]} { ##nagelfar ignore Found constant lappendState mode load } $pathcmd $pos-path $mode $pos {*}$optlist MODULEPATH {*}$pathlist if {[isTopEvaluation]} { ##nagelfar ignore Found constant lpopState mode } } } } proc cmdModuleUse {mode pos args} { if {$mode eq {unload}} { set pos remove } runModuleUse use $mode $pos {*}$args } proc cmdModuleUnuse {mode args} { runModuleUse unuse $mode remove {*}$args } proc cmdModuleAutoinit {} { # skip autoinit process if found already ongoing in current environment if {[get-env __MODULES_AUTOINIT_INPROGRESS] eq {1}} { return } # set environment variable to state autoinit process is ongoing setenv __MODULES_AUTOINIT_INPROGRESS 1 # flag to make renderSettings define the module command setState autoinit 1 # initialize env variables around module command lappendState mode 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 5.3.0 # setenv MODULE_VERSION_STACK 5.3.0 #} # 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 {[get-env MODULEPATH] eq {} && [get-env LOADEDMODULES] eq {}} { # set modpaths defined in modulespath config file if it exists # use .modulespath file in initdir if conf file are located in this dir if {[file readable {/etc/environment-modules/modulespath}]} { set fdata [split [readFile {/etc/environment-modules/modulespath}] \n] foreach fline $fdata { if {[regexp {^\s*(.*?)\s*(#.*|)$} $fline match patharg] == 1\ && $patharg ne {}} { foreach path [split $patharg :] { # resolve path directory in case wildcard character used set globlist [glob -types d -nocomplain $path] if {[llength $globlist] == 0} { lappend pathlist $path } else { lappend pathlist {*}$globlist } } } } if {[info exists pathlist]} { cmdModuleUse load append {*}$pathlist } } # source initialization initrc after modulespaths if it exists # use modulerc file in initdir if conf files are located in this dir if {[file exists {/etc/environment-modules/initrc}]} { lappendState commandname source cmdModuleSource load {/etc/environment-modules/initrc} lpopState commandname } # record what has just been loaded in the virtual init collection setenv __MODULES_LMINIT [getLoadedInit] # if user environment is already initialized, refresh the already loaded # modules unless if environment is inconsistent } elseif {![catch {cacheCurrentModules}]} { cmdModuleRefresh } # default MODULESHOME setenv MODULESHOME [getConf home] # append dir where to find module function for ksh (to get it defined in # interactive and non-interactive sub-shells). also applies for shells # listed in shells_with_ksh_fpath conf if {[getState shell] in [list {*}[split [getConf shells_with_ksh_fpath] :]\ ksh]} { append-path FPATH {/usr/share/Modules/init/ksh-functions} } # define Modules init script as shell startup file if {[getConf set_shell_startup] && [getState shelltype] in [list sh csh\ fish]} { # 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} } if {[getState shelltype] in {sh csh fish}} { # add Modules bin directory to PATH if enabled but do not increase ref # counter variable if already there if {{/usr/share/Modules/bin} ni [split [get-env PATH] :]} { prepend-path --ignore-refcount PATH {/usr/share/Modules/bin} } # add Modules man directory to MANPATH if enabled # initialize MANPATH if not set with a value that preserves manpath # system configuration even after addition of paths to this variable by # modulefiles set manpath {} # use manpath tool if found at configure step, use MANPATH otherwise ##nagelfar ignore +2 Too long line ##nagelfar ignore Found constant catch {set manpath [exec -ignorestderr 2>/dev/null manpath]} #if {[info exists ::env(MANPATH)]} { # set manpath $::env(MANPATH) #} if {{/usr/share/man} ni [split $manpath :]} { if {![info exists ::env(MANPATH)]} { append-path MANPATH {} # ensure no duplicate ':' is set } elseif {[get-env MANPATH] eq {:}} { remove-path MANPATH {} append-path MANPATH {} } prepend-path MANPATH {/usr/share/man} } } # source shell completion script if available, not installed in default # completion locations and only if shell is interactive if {[getState shell] in {tcsh bash fish} && [getState is_stderr_tty]} { set compfile "/usr/share/Modules/init/[getState shell]_completion" if {[file readable $compfile]} { putsModfileCmd dummy "source '$compfile';" } } # clear in progress flag unsetenv __MODULES_AUTOINIT_INPROGRESS lpopState mode } proc cmdModuleInit {args} { set init_cmd [lindex $args 0] set init_list [lrange $args 1 end] set notdone 1 set nomatch 1 # 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([getState 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 "[getState 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\ '[getState 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} { lappendState mode load lappendState commandname $cmd set optlist [list] switch -- $cmd { prepend-path - append-path - remove-path { # by-pass any reference counter, as call is from top level # append/prepend-path: not to increase reference counter if paths are # already defined. remove-path: to ensure paths are removed whatever # their reference counter value lappend optlist --ignore-refcount } } # run modulefile command and get its result if {[catch {$cmd {*}$optlist {*}$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 setState return_false 1 } } } } lpopState commandname lpopState mode } proc cmdModuleTest {args} { lappendState mode test set first_report 1 foreach mod $args { lassign [getPathToModule $mod] modfile modname modnamevr 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 modnamevr $mod displaySeparatorLine } } lpopState mode } proc cmdModuleClear {doit doitset} { # fetch confirmation if no arg passed and force mode disabled if {!$doitset && ![getState force]} { # 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 [getState 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] || [getState force]} { lappendState mode load # unset all Modules runtime variables foreach globvar [getModulesEnvVarGlobList 1] { foreach var [array names ::env -glob $globvar] { unset-env $var } } lpopState mode } else { reportInfo "Modules runtime information were not cleared" } } proc cmdModuleState {args} { if {[llength $args] > 0} { set name [lindex $args 0] } if {[info exists name] && $name ni [concat [array names ::g_state_defs]\ [array names ::g_states]]} { knerror "State '$name' does not exist" } # report module version unless if called by cmdModuleConfig if {[getCallingProcName] ne {cmdModuleConfig}} { reportVersion reportSeparateNextContent } displayTableHeader hi {State name} 24 {Value} 54 # fetch specified state or all states if {[info exists name]} { if {$name in [array names ::g_state_defs]} { set stateval($name) [getState $name 1] } else { set stateval($name) [getState $name] } } else { # define each attribute/fetched state value pair foreach state [array names ::g_state_defs] { set stateval($state) [getState $state 1] } # also get dynamic states (with no prior definition) foreach state [array names ::g_states] { if {![info exists stateval($state)]} { set stateval($state) [getState $state] } } } foreach state [lsort [array names stateval]] { append displist [format {%-25s %s} $state $stateval($state)] \n } report $displist 1 reportSeparateNextContent # only report specified state if any if {[info exists name]} { return } # report environment variable set related to Modules displayTableHeader hi {Env. variable} 24 {Value} 54 set envvar_list {} foreach var [getModulesEnvVarGlobList] { lappend 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 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'" : {}}], value=[expr\ {[info exists value] ? "'$value'" : {}}]" foreach option [array names ::g_config_defs] { lassign $::g_config_defs($option) confvar($option) defval\ conflockable($option) confkind($option) confvalid($option) vtrans\ initproc confvalidkind($option) set confval($option) [getConf $option ] 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 confkind($runenvconf) s set confvtrans($runenvconf) {} set confvalidkind($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])} { # append or subtract value to existing configuration value if new value # starts with '+' or '-' (for colon-separated list option only) if {[info exists value] && $confkind($name) eq {l}} { set curconfvallist [split [getConf $name] :] switch -- [string index $value 0] { + { appendNoDupToList curconfvallist {*}[split [string range\ $value 1 end] :] set value [join $curconfvallist :] } - { lassign [getDiffBetweenList $curconfvallist [split [string\ range $value 1 end] :]] curconfvallist set value [join $curconfvallist :] } } } 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 lappendState mode load unsetenv $confvar($name) lpopState mode } elseif {[llength $confvalid($name)] > 0} { switch -- $confvalidkind($name) { eltlist { # check each element in value list if {[isDiffBetweenList [split $value :] $confvalid($name)]} { reportErrorAndExit "Invalid element in value list for\ config. option '$name'\nAllowed elements are:\ $confvalid($name) (separated by ':')" } else { set validval 1 } } intbe { if {[string is integer -strict $value] && $value >= [lindex\ $confvalid($name) 0] && $value <= [lindex $confvalid($name)\ 1]} { set validval 1 } else { reportErrorAndExit "Invalid value for configuration option\ '$name'\nValue should be an integer comprised between\ [lindex $confvalid($name) 0] and [lindex\ $confvalid($name) 1]" } } {} { ##nagelfar ignore +2 Non static subcommand if {([llength $confvalid($name)] == 1 && ![string is\ $confvalid($name) -strict $value]) || ([llength\ $confvalid($name)] > 1 && $value ni $confvalid($name))} { reportErrorAndExit "Valid values for configuration option\ '$name' are: $confvalid($name)" } else { set validval 1 } } } } else { set validval 1 } if {[info exists validval]} { # effectively set configuration variable lappendState mode load setenv $confvar($name) $value lpopState mode } # 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 { ##nagelfar ignore +2 Suspicious variable name 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} { cmdModuleState } } } proc cmdModuleShToMod {args} { set scriptargs [lassign $args shell script] # evaluate script and get the environment changes it performs translated # into modulefile commands set modcontent [sh-to-mod {*}$args] # output resulting modulefile if {[llength $modcontent] > 0} { report "#%Module" # format each command with tabs and colors if enabled foreach modcmd $modcontent { reportCmd -nativeargrep {*}$modcmd } } } proc cmdModuleEdit {mod} { lassign [getPathToModule $mod] modfile modname # error message has already been produced if mod not found or forbidden if {$modfile ne {}} { # redirect stdout to stderr as stdout is evaluated by module shell func if {[catch {runCommand [getConf editor] $modfile >@stderr 2>@stderr}\ errMsg]} { # re-throw error but as an external one (not as a module issue) knerror $errMsg } } } proc cmdModuleRefresh {} { lappendState mode refresh # create an eval id to track successful/failed module evaluations pushMsgRecordId refresh-[depthState modulename] 0 # load variants from loaded modules cacheCurrentModules foreach lm [getLoadedModulePropertyList refresh] { # prepare info to execute modulefile set vrlist [getVariantList $lm 1] if {[llength $vrlist] > 0} { lassign [parseModuleSpecification 0 0 0 0 $lm {*}$vrlist] lmvr } else { set lmvr $lm } set lmfile [getModulefileFromLoadedModule $lm] set taglist [getExportTagList $lm] # refreshing module is visible by default set hidden 0 set uasked 1 # set a unique id to record messages related to this evaluation. set msgrecid refresh-$lmvr-[depthState modulename] # register record message unique id (now we know mod will be evaluated) pushMsgRecordId $msgrecid # record module title (with the variants and tags of loaded module) # prior module evaluation to get this title ready in case of eval error registerModuleDesignation $msgrecid $lm [getVariantList $lm 7]\ $taglist # run modulefile, restore settings prior evaluation if error and # continue to evaluate the remaining loaded modules pushSettings if {[set errCode [catch { if {[execute-modulefile $lmfile $lm lmvr $lm]} { break } # unloading visibility depends on hidden-loaded tag set hidden [isModuleTagged $lm hidden-loaded 1] # module was asked by user if tagged loaded instead of auto-loaded set uasked [isModuleTagged $lm loaded 1] } errMsg]] != 0 && $errCode != 4} { restoreSettings } popSettings # report all recorded messages for this evaluation (hide evaluation if # loaded mod is set hidden, has been automatically loaded and unloaded) reportMsgRecord "Refreshing [getModuleDesignation $msgrecid {} 2]"\ [expr {$hidden && !$uasked && [depthState evalid] != 1}] popMsgRecordId } popMsgRecordId 0 lpopState mode } proc cmdModuleHelp {args} { lappendState mode help set first_report 1 foreach arg $args { lassign [getPathToModule $arg] modfile modname modnamevr 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 modnamevr $arg displaySeparatorLine } } lpopState mode if {[llength $args] == 0} { reportUsage } } proc cmdModuleTag {unset_extra uasked tag_list args} { reportDebug "tagging $args (unset_extra=$unset_extra, uasked=$uasked,\ tag_list=$tag_list)" set ret 0 foreach mod $args { # find mod among loaded modules lassign [getPathToModule $mod {} 1 match] modfile modname modnamevr\ errkind if {$modfile eq {}} { set ret 1 # go to next module to unload continue } # record tags not already set and if asked unset extra tags not set # anymore lassign [getDiffBetweenList $tag_list [getTagList $modname]] diff_list lassign [getDiffBetweenList [getExtraTagList $modname] $tag_list] \ unset_list if {[llength $diff_list] > 0 || ($unset_extra && [llength $unset_list]\ > 0)} { # set a unique id to record messages related to this evaluation. set msgrecid tag-$modnamevr-[depthState modulename] pushMsgRecordId $msgrecid # record module title (with the variant but no tag list) prior # evaluation to get this title ready in case of error registerModuleDesignation $msgrecid $modname [getVariantList\ $modnamevr 7] {} lappendState mode unload # first unset tags declared for this module on LM env var if {[set modtag [getExportTagList $modname 1]] ne {}} { remove-path __MODULES_LMTAG $modtag } if {[set modtag [getExtraTagList $modname 1]] ne {}} { remove-path __MODULES_LMEXTRATAG $modtag } lpopState mode # remove extra tags currently set not part of tag list if asked if {$unset_extra && [llength $unset_list] > 0} { unsetModuleTag $modname {*}$unset_list unsetModuleExtraTag $modname {*}$unset_list if {$modnamevr ne {} && $modname ne $modnamevr} { unsetModuleTag $modnamevr {*}$unset_list unsetModuleExtraTag $modnamevr {*}$unset_list } } # ensure auto-loaded tag is not preserved if not part of target tags if {$unset_extra && {auto-loaded} ni $tag_list} { unsetModuleTag $modname auto-loaded if {$modnamevr ne {} && $modname ne $modnamevr} { unsetModuleTag $modnamevr auto-loaded } } # record new tags as extra tag excluding tags relative to the way # module is loaded (auto, keep) lassign [getDiffBetweenList $diff_list [list auto-loaded\ keep-loaded]] extradiff_list setModuleTag $modname {*}$diff_list if {[llength $extradiff_list] > 0} { setModuleExtraTag $modname {*}$extradiff_list } if {$modnamevr ne {} && $modname ne $modnamevr} { setModuleTag $modnamevr {*}$diff_list if {[llength $extradiff_list] > 0} { setModuleExtraTag $modnamevr {*}$extradiff_list } } # set the new tag set for module on LM env var lappendState mode load if {[set modtag [getExportTagList $modnamevr 1]] ne {}} { append-path __MODULES_LMTAG $modtag } if {[set modtag [getExtraTagList $modnamevr 1]] ne {}} { append-path __MODULES_LMEXTRATAG $modtag } lpopState mode # update module designation now the additional tags are set registerModuleDesignation $msgrecid $modname [getVariantList\ $modname 7] [getExportTagList $modname] # report tagging evaluation unless hidden and auto-loaded set hidden [isModuleTagged $modnamevr hidden-loaded 1] reportMsgRecord "Tagging [getModuleDesignation $msgrecid {} 2]"\ [expr {$hidden && !$uasked}] popMsgRecordId # indicates that new tags have been applied set ret 2 } } return $ret } proc cmdModuleLint {args} { # stop if no linter defined if {[llength [getConf tcl_linter]] == 0} { knerror {No Tcl linter program configured} } # extract linter program name set linter [file rootname [file tail [lindex [getConf tcl_linter] 0]]] # build command line set linter_mfile [getConf tcl_linter] set linter_mrc [getConf tcl_linter] set linter_gmrc [getConf tcl_linter] # add module-specific syntax database in addition to regular Tcl one #if {$linter eq {nagelfar}} { # lappend linter_mfile -s _\ # -s {/usr/share/Modules/share/nagelfar/syntaxdb_modulefile.tcl}\ # -plugin {/usr/share/Modules/share/nagelfar/plugin_modulefile.tcl} # lappend linter_mrc -s _\ # -s {/usr/share/Modules/share/nagelfar/syntaxdb_modulerc.tcl}\ # -plugin {/usr/share/Modules/share/nagelfar/plugin_modulerc.tcl} # lappend linter_gmrc -s _\ # -s {/usr/share/Modules/share/nagelfar/syntaxdb_modulefile.tcl}\ # -plugin {/usr/share/Modules/share/nagelfar/plugin_globalrc.tcl} #} set global_rclist [getGlobalRcFileList] set modfilelist {} # fetch every available modulefiles if no argument provided if {[llength $args] == 0} { # add global RC files foreach rc $global_rclist { set tolint($rc) gmrc } inhibitErrorReport foreach dir [getModulePathList exiterronundef] { # fetch all existing rc file current user has access to foreach {elt props} [findModules $dir * 0 0] { switch -- [lindex $props 0] { modulerc { set tolint($dir/$elt) mrc } } } # collect all modulefile from dir that current user has access to # getModules will reuse the result collected for findModules foreach {elt props} [getModules $dir *] { switch -- [lindex $props 0] { modulefile - virtual { set tolint([lindex $props 2]) mfile } } } } setState inhibit_errreport 0 } else { foreach mod $args { lassign [getPathToModule $mod] modfile modname modnamevr # error mesg has already been produced if mod not found or forbidden if {$modfile ne {}} { if {$modfile in $global_rclist} { set mkind gmrc } elseif {[file tail $modfile] in {.modulerc .version}} { set mkind mrc } else { set mkind mfile } set tolint($modfile) $mkind } } } # execute linter program over every gathered file foreach lintfile [lsort -dictionary [array names tolint]] { # set a record message unique id and record modulefile title set msgrecid lint-$lintfile pushMsgRecordId $msgrecid registerModuleDesignation $msgrecid $lintfile {} {} ##nagelfar ignore Suspicious variable name if {[catch {set out [runCommand {*}[set linter_$tolint($lintfile)]\ $lintfile]} errMsg]} { # re-throw error but as an external one (not as a module issue) knerror $errMsg } # report linting messages displayLinterOutput $linter $out # report all lint messages for this modulefile reportMsgRecord "Linting [getModuleDesignation $msgrecid {} 2]" popMsgRecordId } } proc cmdModuleModToSh {shell args} { # save shell modulecmd is initialized to ##nagelfar ignore Found constant setState modtosh_real_shell [getState shell] # set shell and shellType states to mod-to-sh target value if {$shell ni [getState supported_shells]} { reportErrorAndExit "Unsupported shell type \'$shell\'" } ##nagelfar ignore Found constant setState shell $shell unsetState shelltype # silence message report (avoid mix with produced shell code) unless if # a debugging mode is set if {![isVerbosityLevel trace]} { unsetConf verbosity set ::asked_verbosity silent } # modulefile evaluation is done against mod-to-sh target shell which means # module-info will return mod-to-sh shell value return [cmdModuleLoad load 1 0 0 {} {*}$args] # after evaluation, renderSettings will produce shell code for mod-to-sh # target shell. modtosh_real_shell state helps to know that shell code has # to be output on report message channel } proc cmdModuleReset {} { # use reset_target_state configuration option to know the environment state # to restore if {[getConf reset_target_state] eq {__purge__}} { cmdModulePurge } else { cmdModuleRestore [getConf reset_target_state] } } proc cmdModuleStash {} { # check if there is something to stash if {[getConf reset_target_state] eq {__purge__}} { # load tags from loaded modules cacheCurrentModules # current environment differs from initial 'purge' state when at least # a module is loaded and it is not super-sticky and not sticky or force # mode is enabled to allow sticky tag unload set diff_from_init 0 foreach mod [getLoadedModulePropertyList name] { if {![isModuleTagged $mod super-sticky 1] && (![isModuleTagged $mod\ sticky 1] || [getState force])} { set diff_from_init 1 break } } } else { # compare current environment against initial collection to check if # something differ set coll [getConf reset_target_state] # get corresponding collection or init, raise error if it does not exist lassign [findCollections $coll exact 0 1] collfile colldesc # fetch collection content and differences compared current environment lassign [getDiffBetweenCurEnvAndColl $collfile $colldesc]\ coll_path_list coll_mod_list coll_tag_arrser coll_nuasked_list\ mod_to_unload mod_to_load path_to_unuse path_to_use is_tags_diff array set coll_tag_arr $coll_tag_arrser set diff_from_init [expr {[llength $mod_to_unload] > 0 || [llength\ $mod_to_load] > 0 || [llength $path_to_unuse] > 0 || [llength\ $path_to_use] > 0 || $is_tags_diff}] } if {!$diff_from_init} { reportWarning {No specific environment to save} return } # record current environment cmdModuleSave stash-[clock milliseconds] # restore initial environment cmdModuleReset } proc cmdModuleStashpop {{stash 0}} { # determine stash collection name from argument set coll [getCollectionFromStash $stash] # restore stash collection environment state cmdModuleRestore $coll # delete stash collection file cmdModuleSaverm $coll } proc cmdModuleStashrm {{stash 0}} { # determine stash collection name from argument set coll [getCollectionFromStash $stash] # delete stash collection file cmdModuleSaverm $coll } proc cmdModuleStashshow {{stash 0}} { # determine stash collection name from argument set coll [getCollectionFromStash $stash] # display stash collection file cmdModuleSaveshow $coll } proc cmdModuleStashclear {} { # get all stash collections (only from current target) set collfile_list [findCollections stash-* glob 0 0 1 1] # delete all stash collections starting from most recent foreach collfile [lsort -decreasing $collfile_list] { # extract collection name (without path and target extension) set coll [file rootname [file tail $collfile]] # delete stash collection file cmdModuleSaverm $coll } } proc cmdModuleStashlist {show_oneperline show_mtime} { cmdModuleSavelist $show_oneperline $show_mtime {} stash-* } proc cmdModuleCachebuild {args} { # use enabled modulepaths when no arg is provided if {[llength $args] > 0} { set modpath_list $args } else { set modpath_list [getModulePathList exiterronundef] } # record cache with module header check options enabled setConf mcookie_check always setConf mcookie_version_check 1 # ignore cache when building cache setConf ignore_cache 1 foreach modpath $modpath_list { set cachefile [getModuleCacheFilename $modpath] # set a record message unique id and record cachefile title set msgrecid cachebuild-$cachefile pushMsgRecordId $msgrecid registerModuleDesignation $msgrecid $cachefile {} {} if {[file isdirectory $modpath]} { if {[file writable $modpath]} { if {[catch { # get cache content for modulepath set cache [formatModuleCacheContent $modpath] if {[string length $cache] == 0} { reportWarning {Nothing to record in cache file} } else { # record cache content in file set fid [open $cachefile w] # use defined buffer size to limit num of write system call fconfigure $fid -buffersize [getConf cache_buffer_bytes] puts $fid $cache close $fid } } errMsg]} { # report error occurring during cache content format or cache # file write reportError $errMsg } } else { reportWarning {Cannot build cache file, directory is not writable} } } else { reportError "'$modpath' is not a directory" } # report all messages for this cachefile creation reportMsgRecord "Creating [getModuleDesignation $msgrecid {} 2]" popMsgRecordId } } proc cmdModuleCacheclear {} { foreach modpath [getModulePathList exiterronundef] { set cachefile [getModuleCacheFilename $modpath] if {[file exists $cachefile]} { # set a record message unique id and record cachefile title set msgrecid cacheclear-$cachefile pushMsgRecordId $msgrecid registerModuleDesignation $msgrecid $cachefile {} {} if {[file writable $modpath]} { if {[catch {file delete $cachefile} errMsg]} { reportError $errMsg } } else { reportWarning {Cannot remove cache file, directory is not\ writable} } # report all messages for this cachefile deletion reportMsgRecord "Deleting [getModuleDesignation $msgrecid {} 2]" popMsgRecordId } } } # exit in a clean manner by flushing and closing interaction with external # components proc flushAndExit {code} { # output all shell code generated on stdout renderFlush # output last messages on the report file descriptor and close it reportFlush exit $code } # runs the global RC files if they exist proc runModulerc {} { setState rc_running 1 foreach rc [getGlobalRcFileList] { reportDebug "Executing $rc" cmdModuleSource load $rc lappendState rc_loaded $rc } unsetState rc_running # 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] } proc aboveCommandName {} { return [lindex [getState commandname] end-1] } proc ongoingCommandName {commandName} { return [expr {[lsearch -exact [getState commandname] $commandName] != -1}] } # Know if we are currently at the top evaluation level: (1) at the modulecmd # level (module command written by user in terminal or script) or (2) during # the evaluation of rc or modulefile by a source or autoinit sub-command # triggered from modulecmd level or (3) during the evaluation of global rc # file. (2) and (3) are considered "extended" top evaluation contexts. proc isTopEvaluation {{extended 1}} { return [expr {[depthState modulename] == 0 || ($extended && [depthState\ modulename] == 1 && ([aboveCommandName] in {source autoinit} ||\ [isStateDefined rc_running]))}] } # 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} try-add {set command try-load} add-any {set command load-any} 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 refresh 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 [expr {$command in [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\ sh-to-mod edit try-load refresh state load-any lint mod-to-sh reset\ stash stashpop stashrm stashshow stashclear stashlist cachebuild\ cacheclear]}] reportDebug "(command=$command, cmdvalid=$cmdvalid, cmdempty=$cmdempty)" return [list $command $cmdvalid $cmdempty] } # analyze arg list passed to a module cmd to set options proc parseModuleCommandArgs {topcall cmd ignerr 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 addpath_pos prepend set not_req 0 set tag_list {} set otherargs {} # parse argument list foreach arg $args { if {[info exists nextargisval]} { ##nagelfar vartype nextargisval varName set $nextargisval $arg unset nextargisval } elseif {[info exists nextargisvaltosplit]} { ##nagelfar vartype nextargisvaltosplit varName set $nextargisvaltosplit [split $arg :] unset nextargisvaltosplit } elseif {[info exists ignore_next_arg]} { unset ignore_next_arg } else { switch -glob -- $arg { -j - --json { # enable json output only on supported command if {$cmd in [list avail savelist stashlist list search\ whatis]} { setState report_format json set show_oneperline 0 set show_mtime 0 } } -t - --terse { set show_oneperline 1 set show_mtime 0 setState report_format terse } -l - --long { set show_mtime 1 set show_oneperline 0 setState report_format long } -o { # option is only valid for specific sub-commands if {$cmd in [list avail list]} { set nextargisval asked_output set output_arg -o } else { if {!$ignerr} { knerror "Unsupported option '$arg' on $cmd sub-command" } set ignore_next_arg 1 } } --output=* { # option is only valid for specific sub-commands if {$cmd in [list avail list]} { set asked_output [string range $arg 9 end] set output_arg --output } elseif {!$ignerr} { knerror "Unsupported option '--output' on $cmd sub-command" } } --tag=* - --tag { # option is only valid for specific sub-commands # unload allowed not to raise error on unload/load mixed ml cmd if {$cmd in [list load try-load load-any switch unload]} { if {$arg eq {--tag}} { ##nagelfar ignore Found constant set nextargisvaltosplit tag_list } else { set tag_list [split [string range $arg 6 end] :] if {[llength $tag_list] == 0} { knerror "Missing value for '--tag' option" } } } elseif {!$ignerr} { knerror "Unsupported option '--tag' on $cmd sub-command" } } --append - -append { if {$cmd eq {use}} { set addpath_pos append } else { lappend otherargs $arg } } -p - --prepend - -prepend { if {$cmd eq {use}} { set addpath_pos prepend } else { lappend otherargs $arg } } --all { # include hidden modules only on a limited set of command if {$cmd in [list avail aliases search whatis ml list lint\ savelist]} { setState hiding_threshold 2 } else { lappend otherargs $arg } } -a { # -a option has a different meaning whether sub-command is use # or one of the search/listing sub-commands if {$cmd eq {use}} { set addpath_pos append } elseif {$cmd in [list avail aliases search whatis ml list\ lint savelist]} { setState hiding_threshold 2 } else { lappend otherargs $arg } } -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'" } --not-req { if {!$topcall && $cmd in [list load try-load load-any unload\ switch]} { set not_req 1 } else { knerror "Unsupported option '$arg' on $cmd sub-command" } } --output { knerror "Missing value for '$arg' option" } default { lappend otherargs $arg } } set prevarg $arg } } if {[info exists nextargisval] || [info exists nextargisvaltosplit]} { knerror "Missing value for '$prevarg' option" } foreach tag $tag_list { if {$tag in [list loaded auto-loaded forbidden nearly-forbidden\ hidden]} { knerror "Tag '$tag' cannot be manually set" } } if {[info exists asked_output]} { if {[getState report_format] in [list long json]} { knerror "Unsupported option '$output_arg' on [getState\ report_format] output mode" } else { # get config name relative to current sub-command and output format set outputconf $cmd if {[getState report_format] ne {regular}} { append outputconf _[getState report_format] } append outputconf _output # check option value is coherent with current sub-command (remove # append/subtract operator at the start if any) if {[isDiffBetweenList [split [expr {[string index $asked_output 0]\ in {+ -} ? [string range $asked_output 1 end] : $asked_output}]\ :] [lindex $::g_config_defs($outputconf) 4]]} { if {!$ignerr} { knerror "Invalid element in value list for '$output_arg'\ option on $cmd sub-command\nAllowed elements are: [lindex\ $::g_config_defs($outputconf) 4] (separated by ':')" } } else { ##nagelfar ignore Suspicious variable name set ::asked_$outputconf $asked_output } } } 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,\ addpath_pos=$addpath_pos, not_req=$not_req, tag_list=$tag_list,\ otherargs=$otherargs)" return [list $show_oneperline $show_mtime $show_filter $search_filter\ $search_match $dump_state $addpath_pos $not_req $tag_list $otherargs] } proc module {command args} { # guess if called from top level set topcall [isTopEvaluation 0] set tryhelpmsg [expr {$topcall ? "\nTry 'module --help' for more\ information." : {}}] if {$topcall} { set msgprefix {} } else { set msgprefix {module: } } # get mode, set to load if called from top level set mode [expr {$topcall ? {load} : [currentState mode]}] # 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 [parseModuleCommandArgs $topcall $command 0 {*}$args]\ show_oneperline show_mtime show_filter search_filter search_match\ dump_state addpath_pos not_req tag_list args # parse module version specification defineParseModuleSpecificationProc [getConf advanced_version_spec] if {$command in [list avail paths whatis load unload switch help test\ display path is-avail edit try-load load-any list lint mod-to-sh\ source]} { # some cmds allow to express variant without module name set allow_noname_spec [expr {$command in {avail list paths whatis}}] # some cmds allow extra specifier in query set allow_xt_spec [expr {$command in {avail paths whatis}}] set args [parseModuleSpecification 0 $allow_noname_spec $allow_xt_spec\ 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 - sh-to-mod - edit - refresh - source - state -\ lint - mod-to-sh - reset - stash - stashpop - stashrm - stashshow -\ stashclear - stashlist - cachebuild - cacheclear { 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 {([depthState modulename] > 1 || [currentState commandname] ni [list\ source autoinit]) && $command eq {config}} { knerror "${msgprefix}Command '$command' not supported$tryhelpmsg" } # no requirement should be recorded this module load/unload/switch cmd if {$not_req || ![getConf implicit_requirement]} { lappendState inhibit_req_record [currentState evalid] } } # argument number check switch -- $command { unload - source - display - initadd - initprepend - initrm - test -\ is-avail - try-load - load-any { if {[llength $args] == 0} { set argnberr 1 } } refresh - reload - aliases - purge - initlist - initclear - autoinit -\ reset - stash - stashclear - stashlist - cacheclear { if {[llength $args] != 0} { set argnberr 1 } } switch { if {[llength $args] == 0 || [llength $args] > 2} { set argnberr 1 } } path - paths - info-loaded - edit { if {[llength $args] != 1} { set argnberr 1 } } search - save - restore - saverm - saveshow - clear - state - stashpop\ - stashrm - stashshow { if {[llength $args] > 1} { set argnberr 1 } } initswitch { if {[llength $args] != 2} { set argnberr 1 } } prepend-path - append-path - remove-path - sh-to-mod - mod-to-sh { 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 lappendState always_read_full_file [expr {$command ni [list path paths\ list avail aliases edit]}] lappendState commandname $command if {$topcall} { # Find and execute any global rc file found runModulerc } switch -- $command { load - try-load - load-any { # 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 {[isTopEvaluation]} { # is eval a regular attempt or a try (silence not found error) set tryload [expr {$command in {try-load load-any}}] set loadany [expr {$command eq {load-any}}] set ret [cmdModuleLoad load 1 $tryload $loadany $tag_list\ {*}$args] } elseif {$mode eq {load}} { # auto load is inhibited if currently in DepRe context only # register requirement set subauto [expr {[currentModuleEvalContext] eq {depre} ? {0}\ : {1}}] if {$command eq {try-load}} { # attempt load of not already loaded modules if {$subauto} { foreach arg $args { lassign [loadRequirementModuleList 1 0 $tag_list\ $arg] retlo # update return value if an issue occurred unless # force mode is enabled if {$retlo != 0 && ![getState force]} { set ret $retlo } } } # record requirement as optional: no error if not loaded # but reload will be triggered if loaded later on prereqAllModfileCmd 1 0 --optional --tag [join $tag_list :]\ {*}$args } elseif {$command eq {load-any}} { # load and register requirement in a OR-operation prereqAnyModfileCmd 1 $subauto --tag [join $tag_list :]\ {*}$args } else { # load and register requirement in a AND-operation prereqAllModfileCmd 0 $subauto --tag [join $tag_list :]\ {*}$args } # mods unload is handled via UReqUn mechanism when auto enabled # (unless if implicit_requirement has been inhibited) also unloads # are triggered by ongoing reload, purge, restore, reset, stash or # stashpop cmds } elseif {(![getConf auto_handling] || [getState\ inhibit_req_record] eq [currentState evalid]) &&\ [aboveCommandName] ni [list purge reload restore reset stash\ stashpop]} { # 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 [getLoadedModulePropertyList name] set modidx [lsearch -exact $modlist [currentState modulename]] 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\ [getModuleDesignation loaded $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 {[isTopEvaluation]} { set ret [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 [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 } } } refresh { cmdModuleRefresh } reload { cmdModuleReload } use { cmdModuleUse $mode $addpath_pos {*}$args } unuse { cmdModuleUnuse $mode {*}$args } source { cmdModuleSource load {*}$args } switch { # pass 'user asked state' to switch procedure set uasked [isTopEvaluation] if {$uasked} { cmdModuleSwitch $uasked $tag_list {*}$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 { cmdModuleSwitch $uasked $tag_list {*}$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 (unless if # implicit_requirement has been inhibited). Also unloads are # triggered by ongoing reload, purge, restore, reset, stash # or stashpop cmds if {(![getConf auto_handling] || [getState\ inhibit_req_record] eq [currentState evalid]) &&\ $swlomod ne {} && [aboveCommandName] ni [list purge\ reload restore reset stash stashpop]} { # unload mod if it was loaded prior this mod, not user # asked and not required by another loaded module set modlist [getLoadedModulePropertyList name] set modidx [lsearch -exact $modlist [currentState\ modulename]] 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\ [getModuleDesignation loaded $unmod] failed"\ 1 } } } } } } } } display { cmdModuleDisplay {*}$args } avail { {*}cmdModuleAvail $show_oneperline $show_mtime $show_filter\ $search_filter $search_match {*}$args } aliases { cmdModuleAliases } path { cmdModulePath {*}$args } paths { cmdModulePaths {*}$args } list { cmdModuleList $show_oneperline $show_mtime $search_match {*}$args } whatis { if {$args ne {}} { foreach arg $args { cmdModuleWhatIs $arg } } else { cmdModuleWhatIs } } search { cmdModuleApropos {*}$args } purge { cmdModulePurge } save { cmdModuleSave {*}$args } restore { cmdModuleRestore {*}$args } saverm { cmdModuleSaverm {*}$args } saveshow { cmdModuleSaveshow {*}$args } savelist { cmdModuleSavelist $show_oneperline $show_mtime $search_match {*}$args } initadd { cmdModuleInit add {*}$args } initprepend { cmdModuleInit prepend {*}$args } initswitch { cmdModuleInit switch {*}$args } initrm { cmdModuleInit rm {*}$args } initlist { cmdModuleInit list {*}$args } initclear { cmdModuleInit clear {*}$args } autoinit { cmdModuleAutoinit } clear { # ensure empty string is correctly passed cmdModuleClear [lindex $args 0] [llength $args] } config { cmdModuleConfig $dump_state {*}$args } state { cmdModuleState {*}$args } sh-to-mod { cmdModuleShToMod {*}$args } edit { cmdModuleEdit {*}$args } lint { cmdModuleLint {*}$args } mod-to-sh { cmdModuleModToSh {*}$args } reset { cmdModuleReset } stash { cmdModuleStash } stashpop { cmdModuleStashpop {*}$args } stashrm { cmdModuleStashrm {*}$args } stashshow { cmdModuleStashshow {*}$args } stashclear { cmdModuleStashclear } stashlist { cmdModuleStashlist $show_oneperline $show_mtime } cachebuild { cmdModuleCachebuild {*}$args } cacheclear { cmdModuleCacheclear } help { cmdModuleHelp {*}$args } test { cmdModuleTest {*}$args } prepend-path - append-path - remove-path - is-loaded - is-saved -\ is-used - is-avail { cmdModuleResurface $command {*}$args } info-loaded { cmdModuleResurface module-info loaded {*}$args } } lpopState commandname lpopState always_read_full_file if {!$topcall && ($not_req || ![getConf implicit_requirement])} { lpopState inhibit_req_record } # if called from top level render settings if any if {$topcall} { renderSettings } return {} } proc ml {args} { # filter out all known options from argument list to guess command name # without them in the way lassign [parseModuleCommandArgs 1 ml 1 {*}$args] show_oneperline\ show_mtime show_filter search_filter search_match dump_state\ addpath_pos not_req tag_list 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} { module $command {*}$margs } else { # parse specified module and get list of mods to unload and mods to load defineParseModuleSpecificationProc [getConf advanced_version_spec] lassign [parseModuleSpecification 1 0 0 0 {*}$fargs] modunlist modlolist # main procedure has already raised error for badly written argument # like '-' or '--', but we need here to replay module-specific argument # parsing to raise error if some arg are not allowed on unload/load cmd set mlcmd [expr {[llength $modunlist] > 0 ? {unload} : {load}}] lassign [parseModuleCommandArgs 1 $mlcmd 0 {*}$args] show_oneperline\ show_mtime show_filter search_filter search_match dump_state\ addpath_pos not_req tag_list fargs # define if modfile should always be fully read even for validity check lappendState always_read_full_file 1 lappendState commandname ml # Find and execute any global rc file found runModulerc set ret 0 pushSettings # first unload specified modules if {[llength $modunlist] > 0} { set ret [cmdModuleUnload unload match 1 0 0 0 {*}$modunlist] } # then load other modules unless unload phase failed if {!$ret && [llength $modlolist] > 0} { set ret [cmdModuleLoad load 1 0 0 $tag_list {*}$modlolist] } # rollback changes if any load or unload failed if {$ret} { restoreSettings } popSettings lpopState commandname lpopState always_read_full_file renderSettings } return {} } # # 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 setState cmdline "$argv0 $argv" # Load extension library if enabled ##nagelfar ignore +2 Too long line if {[file readable [getConf tcl_ext_lib]]} { reportDebug "Load Tcl extension library ([getConf tcl_ext_lib])" load [file normalize [getConf tcl_ext_lib]] Envmodules setState tcl_ext_lib_loaded 1 } # use fallback procs if extension library is not loaded if {[info commands readFile] eq {}} { rename ::__readFile ::readFile rename ::__getFilesInDirectory ::getFilesInDirectory rename ::__initStateUsergroups ::initStateUsergroups rename ::__initStateUsername ::initStateUsername rename ::__initStateClockSeconds ::initStateClockSeconds rename ::__parseDateTimeArg ::parseDateTimeArg } ##nagelfar syntax readFile x x? x? ##nagelfar syntax getFilesInDirectory x x ##nagelfar syntax initStateUsergroups ##nagelfar syntax initStateUsername ##nagelfar syntax initStateClockSeconds ##nagelfar syntax parseDateTimeArg x x # source site configuration script if any sourceSiteConfig setState supported_shells {sh bash ksh zsh csh tcsh fish cmd tcl perl\ python ruby lisp cmake r} # Parse shell setState shell [lindex $argv 0] if {[getState shell] ni [getState supported_shells]} { reportErrorAndExit "Unknown shell type \'([getState shell])\'" } # extract options and command switches from other args set otherargv {} 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') ##nagelfar ignore #2 Badly formed if statement set argtoparse [if {[llength [lindex $argv 1]] > 1} {list {*}[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 } elseif {[info exists nextargisextraargv]} { lappend extraargv $arg unset nextargisextraargv } elseif {[info exists nextargisval]} { ##nagelfar vartype nextargisval varName set $nextargisval $arg unset nextargisval } else { switch -glob -- $arg { -T - --trace { set asked_verbosity trace } -D - -DD - --debug { set asked_verbosity [expr {$arg eq {-DD} || ([info exists\ asked_verbosity] && $asked_verbosity in {debug debug2}) ?\ {debug2} : {debug}}] } -s - --silent { set asked_verbosity silent } -v - -vv - --verbose { set asked_verbosity [expr {$arg eq {-vv} || ([info exists\ asked_verbosity] && $asked_verbosity in {verbose verbose2})\ ? {verbose2} : {verbose}}] } --help - -h { set show_help 1 } -V - --version { set show_version 1 } --paginate { set asked_paginate 1 } --no-pager { set asked_paginate 0 } --redirect { if {[getState shelltype] ni {sh fish}} { reportWarning "Unsupported option '--redirect' on [getState\ shell] shell" } else { set asked_redirect_output 1 } } --no-redirect - --no_redirect { set asked_redirect_output 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 {$asked_color ni [lindex $::g_config_defs(color) 4]} { unset asked_color } } -o { # add with next arg to the command-specific switches lappend extraargv $arg set nextargisextraargv 1 } --width* { set asked_term_width [string range $arg 8 end] set term_width_arg --width if {$asked_term_width eq {}} { set asked_term_width 0 } } -w { ##nagelfar ignore Found constant set nextargisval asked_term_width set term_width_arg -w } -t - --terse - -l - --long - --default - -L - --latest - -S -\ --starts-with - -C - --contains - -j - --json - --output=* { # 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 - --all - -p - --prepend - -prepend -\ --delim - -delim - --delim=* - -delim=* - --duplicates - --index\ - --notuasked - --indepth - --no-indepth - --dump-state -\ --reset - --tag - --tag=* { # 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 } --ignore-cache - --ignore_cache { set asked_ignore_cache 1 } --ignore-user-rc { set asked_ignore_user_rc 1 } --timer { setState timer 1 set timer_start [clock microseconds] } --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 } --output { reportErrorAndExit "Missing value for '$arg' option\nTry\ 'module --help' for more information." } --initial_load { # ignore option for compatibility } {-} - {--} - {--*} { reportErrorAndExit "Invalid option '$arg'\nTry 'module --help'\ for more information." } -* { # verify current command accepts minus arg (-*) if {![info exists accept_minus_arg] && [llength $otherargv]\ > 0} { set subcmdtest [lindex $otherargv 0] if {$subcmdtest ne {ml}} { lassign [parseModuleCommandName $subcmdtest {}]\ subcmdtest } # accepted if command is ml or config or if adv vers spec is # enabled and command can receive boolean variant # specification set accept_minus_arg [expr {$subcmdtest in {ml config} ||\ ([getConf advanced_version_spec] && $subcmdtest in\ {avail list display help is-avail is-loaded load path\ paths switch test unload whatis mod-to-sh source})}] } # spare argument if minus arg is accepted if {[info exists accept_minus_arg] && $accept_minus_arg} { lappend otherargv $arg } else { reportErrorAndExit "Invalid option '$arg'\nTry 'module\ --help' for more information." } } default { lappend otherargv $arg } } set prevarg $arg } } if {[info exists nextargisextraargv]} { reportErrorAndExit "Missing value for '$prevarg' option\nTry 'module\ --help' for more information." } if {[info exists asked_term_width]} { set rangewidth [lindex $::g_config_defs(term_width) 4] if {[string is integer -strict $::asked_term_width] && \ $::asked_term_width >= [lindex $rangewidth 0] &&\ $::asked_term_width <= [lindex $rangewidth 1]} { set validval 1 } else { reportErrorAndExit "Invalid value for option\ '$term_width_arg'\nValue should be an integer comprised between\ [lindex $rangewidth 0] and [lindex $rangewidth 1]" } } setState subcmd [lindex $otherargv 0] set otherargv [list {*}[lreplace $otherargv 0 0] {*}$extraargv] setState subcmd_args $otherargv # call ml frontend if it is asked command if {[getState subcmd] eq {ml}} { set execcmdlist [list ml {*}$otherargv] } else { set execcmdlist [list module [getState subcmd] {*}$otherargv] } # now options are known initialize error report (start pager if enabled) initErrorReport # put back quarantine variables in env, if quarantine mechanism supported if {[info exists env(__MODULES_QUARANTINE_SET)] &&\ $env(__MODULES_QUARANTINE_SET) eq {1}} { foreach var [split [getConf run_quarantine]] { # check variable name is valid if {[regexp {^[A-Za-z_][A-Za-z0-9_]*$} $var]} { set quarvar __MODULES_QUAR_${var} # 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 {[getState subcmd] eq {ml}} { reportMlUsage } else { reportUsage } flushAndExit 0 } if {$show_version} { reportVersion flushAndExit 0 } # no modulefile is currently being interpreted lappendState modulefile {} # eval needed to pass otherargv as list to module proc {*}$execcmdlist } errMsg ]} { # re-enable error report in case it was previously inhibited setState inhibit_errreport 0 # 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 {$errorCode ni [list MODULES_ERR_RENDERED MODULES_ERR_KNOWN]} { 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 flushAndExit 1 } flushAndExit 0