punkcheck-managed regeneration propagating the G-049 module releases (parse-status data model, machine-parsable cmdhelp returns) into src/bootsupport/modules, the punk.project-0.1 and punk.shell-0.1 layout bootsupport copies, and _vfscommon.vfs/modules.
Assisted-by: harness=claude; primary-model=claude-fable-5; api-location=anthropic.com
#map each member of an -alias1|-alias2|-realname optionset to the optionset (the ARG_INFO key)
set lookup_optset [dict create]
foreach optionset [dict get $form_dict OPT_NAMES] {
foreach o [split $optionset |] {
dict set lookup_optset $o $optionset
}
}
#received argument names normalized to definition argument names.
#received is dict-like but may repeat keys for -multiple arguments; values are clause ordinals.
set receivednames [list]
set positions [dict create] ;#argname -> list of clause ordinals
foreach {r rpos} [Dict_getdef $parsedargs received {}] {
if {[string match -* $r] && [dict exists $lookup_optset $r]} {
set r [dict get $lookup_optset $r]
}
if {$r ni $receivednames} {
lappend receivednames $r
}
dict lappend positions $r $rpos
}
if {$badarg ne "" && [string match -* $badarg] && [dict exists $lookup_optset $badarg]} {
set badarg [dict get $lookup_optset $badarg]
}
set parsed_leaders [Dict_getdef $parsedargs leaders {}]
set parsed_opts [Dict_getdef $parsedargs opts {}]
set parsed_values [Dict_getdef $parsedargs values {}]
set argstatus [dict create]
foreach {names class parsedvalues} [list {*}{
} [dict get $form_dict LEADER_NAMES] leader {*}{
} $parsed_leaders {*}{
} [dict get $form_dict OPT_NAMES] option {*}{
} $parsed_opts {*}{
} [dict get $form_dict VAL_NAMES] value {*}{
} $parsed_values {*}{
}] {
foreach arg $names {
set argpositions [Dict_getdef $positions $arg {}]
set received [llength $argpositions]
if {$arg eq $badarg} {
set status bad
set argfailclass [dict get $opts -failureclass]
} elseif {$received > 0} {
set status ok
set argfailclass ""
} else {
set status unparsed
set argfailclass ""
}
#value-in-effect (includes values the parse filled from -default).
#Direct lookup by definition argument name, matching the display renderers:
#aliased optionsets store under their canonical name and are not resolved here.
if {[dict exists $parsedvalues $arg]} {
set hasvalue 1
set value [dict get $parsedvalues $arg]
} else {
set hasvalue 0
set value ""
}
dict set argstatus $arg [dict create class $class status $status received $received positions $argpositions hasvalue $hasvalue value $value failureclass $argfailclass]
}
}
return [dict create {*}{
} ok [dict get $opts -ok] {*}{
} status [dict get $opts -status] {*}{
} scheme [dict get $opts -scheme] {*}{
} message [dict get $opts -message] {*}{
} errorcode [dict get $opts -errorcode] {*}{
} failureclass [dict get $opts -failureclass] {*}{
} badarg $badarg {*}{
} id [Dict_getdef $spec_dict id ""] {*}{
} form $fid {*}{
} receivednames $receivednames {*}{
} argstatus $argstatus {*}{
}]
}
#resolve the form name whose argument set parse-status per-argument entries cover
#(first form matching the -form selection - mirrors arg_error's display-form resolution)
#map each member of an -alias1|-alias2|-realname optionset to the optionset (the ARG_INFO key)
set lookup_optset [dict create]
foreach optionset [dict get $form_dict OPT_NAMES] {
foreach o [split $optionset |] {
dict set lookup_optset $o $optionset
}
}
#received argument names normalized to definition argument names.
#received is dict-like but may repeat keys for -multiple arguments; values are clause ordinals.
set receivednames [list]
set positions [dict create] ;#argname -> list of clause ordinals
foreach {r rpos} [Dict_getdef $parsedargs received {}] {
if {[string match -* $r] && [dict exists $lookup_optset $r]} {
set r [dict get $lookup_optset $r]
}
if {$r ni $receivednames} {
lappend receivednames $r
}
dict lappend positions $r $rpos
}
if {$badarg ne "" && [string match -* $badarg] && [dict exists $lookup_optset $badarg]} {
set badarg [dict get $lookup_optset $badarg]
}
set parsed_leaders [Dict_getdef $parsedargs leaders {}]
set parsed_opts [Dict_getdef $parsedargs opts {}]
set parsed_values [Dict_getdef $parsedargs values {}]
set argstatus [dict create]
foreach {names class parsedvalues} [list {*}{
} [dict get $form_dict LEADER_NAMES] leader {*}{
} $parsed_leaders {*}{
} [dict get $form_dict OPT_NAMES] option {*}{
} $parsed_opts {*}{
} [dict get $form_dict VAL_NAMES] value {*}{
} $parsed_values {*}{
}] {
foreach arg $names {
set argpositions [Dict_getdef $positions $arg {}]
set received [llength $argpositions]
if {$arg eq $badarg} {
set status bad
set argfailclass [dict get $opts -failureclass]
} elseif {$received > 0} {
set status ok
set argfailclass ""
} else {
set status unparsed
set argfailclass ""
}
#value-in-effect (includes values the parse filled from -default).
#Direct lookup by definition argument name, matching the display renderers:
#aliased optionsets store under their canonical name and are not resolved here.
if {[dict exists $parsedvalues $arg]} {
set hasvalue 1
set value [dict get $parsedvalues $arg]
} else {
set hasvalue 0
set value ""
}
dict set argstatus $arg [dict create class $class status $status received $received positions $argpositions hasvalue $hasvalue value $value failureclass $argfailclass]
}
}
return [dict create {*}{
} ok [dict get $opts -ok] {*}{
} status [dict get $opts -status] {*}{
} scheme [dict get $opts -scheme] {*}{
} message [dict get $opts -message] {*}{
} errorcode [dict get $opts -errorcode] {*}{
} failureclass [dict get $opts -failureclass] {*}{
} badarg $badarg {*}{
} id [Dict_getdef $spec_dict id ""] {*}{
} form $fid {*}{
} receivednames $receivednames {*}{
} argstatus $argstatus {*}{
}]
}
#resolve the form name whose argument set parse-status per-argument entries cover
#(first form matching the -form selection - mirrors arg_error's display-form resolution)
#map each member of an -alias1|-alias2|-realname optionset to the optionset (the ARG_INFO key)
set lookup_optset [dict create]
foreach optionset [dict get $form_dict OPT_NAMES] {
foreach o [split $optionset |] {
dict set lookup_optset $o $optionset
}
}
#received argument names normalized to definition argument names.
#received is dict-like but may repeat keys for -multiple arguments; values are clause ordinals.
set receivednames [list]
set positions [dict create] ;#argname -> list of clause ordinals
foreach {r rpos} [Dict_getdef $parsedargs received {}] {
if {[string match -* $r] && [dict exists $lookup_optset $r]} {
set r [dict get $lookup_optset $r]
}
if {$r ni $receivednames} {
lappend receivednames $r
}
dict lappend positions $r $rpos
}
if {$badarg ne "" && [string match -* $badarg] && [dict exists $lookup_optset $badarg]} {
set badarg [dict get $lookup_optset $badarg]
}
set parsed_leaders [Dict_getdef $parsedargs leaders {}]
set parsed_opts [Dict_getdef $parsedargs opts {}]
set parsed_values [Dict_getdef $parsedargs values {}]
set argstatus [dict create]
foreach {names class parsedvalues} [list {*}{
} [dict get $form_dict LEADER_NAMES] leader {*}{
} $parsed_leaders {*}{
} [dict get $form_dict OPT_NAMES] option {*}{
} $parsed_opts {*}{
} [dict get $form_dict VAL_NAMES] value {*}{
} $parsed_values {*}{
}] {
foreach arg $names {
set argpositions [Dict_getdef $positions $arg {}]
set received [llength $argpositions]
if {$arg eq $badarg} {
set status bad
set argfailclass [dict get $opts -failureclass]
} elseif {$received > 0} {
set status ok
set argfailclass ""
} else {
set status unparsed
set argfailclass ""
}
#value-in-effect (includes values the parse filled from -default).
#Direct lookup by definition argument name, matching the display renderers:
#aliased optionsets store under their canonical name and are not resolved here.
if {[dict exists $parsedvalues $arg]} {
set hasvalue 1
set value [dict get $parsedvalues $arg]
} else {
set hasvalue 0
set value ""
}
dict set argstatus $arg [dict create class $class status $status received $received positions $argpositions hasvalue $hasvalue value $value failureclass $argfailclass]
}
}
return [dict create {*}{
} ok [dict get $opts -ok] {*}{
} status [dict get $opts -status] {*}{
} scheme [dict get $opts -scheme] {*}{
} message [dict get $opts -message] {*}{
} errorcode [dict get $opts -errorcode] {*}{
} failureclass [dict get $opts -failureclass] {*}{
} badarg $badarg {*}{
} id [Dict_getdef $spec_dict id ""] {*}{
} form $fid {*}{
} receivednames $receivednames {*}{
} argstatus $argstatus {*}{
}]
}
#resolve the form name whose argument set parse-status per-argument entries cover
#(first form matching the -form selection - mirrors arg_error's display-form resolution)
#map each member of an -alias1|-alias2|-realname optionset to the optionset (the ARG_INFO key)
set lookup_optset [dict create]
foreach optionset [dict get $form_dict OPT_NAMES] {
foreach o [split $optionset |] {
dict set lookup_optset $o $optionset
}
}
#received argument names normalized to definition argument names.
#received is dict-like but may repeat keys for -multiple arguments; values are clause ordinals.
set receivednames [list]
set positions [dict create] ;#argname -> list of clause ordinals
foreach {r rpos} [Dict_getdef $parsedargs received {}] {
if {[string match -* $r] && [dict exists $lookup_optset $r]} {
set r [dict get $lookup_optset $r]
}
if {$r ni $receivednames} {
lappend receivednames $r
}
dict lappend positions $r $rpos
}
if {$badarg ne "" && [string match -* $badarg] && [dict exists $lookup_optset $badarg]} {
set badarg [dict get $lookup_optset $badarg]
}
set parsed_leaders [Dict_getdef $parsedargs leaders {}]
set parsed_opts [Dict_getdef $parsedargs opts {}]
set parsed_values [Dict_getdef $parsedargs values {}]
set argstatus [dict create]
foreach {names class parsedvalues} [list {*}{
} [dict get $form_dict LEADER_NAMES] leader {*}{
} $parsed_leaders {*}{
} [dict get $form_dict OPT_NAMES] option {*}{
} $parsed_opts {*}{
} [dict get $form_dict VAL_NAMES] value {*}{
} $parsed_values {*}{
}] {
foreach arg $names {
set argpositions [Dict_getdef $positions $arg {}]
set received [llength $argpositions]
if {$arg eq $badarg} {
set status bad
set argfailclass [dict get $opts -failureclass]
} elseif {$received > 0} {
set status ok
set argfailclass ""
} else {
set status unparsed
set argfailclass ""
}
#value-in-effect (includes values the parse filled from -default).
#Direct lookup by definition argument name, matching the display renderers:
#aliased optionsets store under their canonical name and are not resolved here.
if {[dict exists $parsedvalues $arg]} {
set hasvalue 1
set value [dict get $parsedvalues $arg]
} else {
set hasvalue 0
set value ""
}
dict set argstatus $arg [dict create class $class status $status received $received positions $argpositions hasvalue $hasvalue value $value failureclass $argfailclass]
}
}
return [dict create {*}{
} ok [dict get $opts -ok] {*}{
} status [dict get $opts -status] {*}{
} scheme [dict get $opts -scheme] {*}{
} message [dict get $opts -message] {*}{
} errorcode [dict get $opts -errorcode] {*}{
} failureclass [dict get $opts -failureclass] {*}{
} badarg $badarg {*}{
} id [Dict_getdef $spec_dict id ""] {*}{
} form $fid {*}{
} receivednames $receivednames {*}{
} argstatus $argstatus {*}{
}]
}
#resolve the form name whose argument set parse-status per-argument entries cover
#(first form matching the -form selection - mirrors arg_error's display-form resolution)
