if {[lindex $cmd 0] ne "literal"
        || [catch {info args [lindex $cmd 1]} arginfo]} {
        return {0 {}}
    } else {
        return [list 1 $arginfo]
    }
}














































 
# quadcode::transformer method va_PrepareArgs --
#
#	Emits code to prepare the arguments for an 'invoke' or
#	'invokeExpanded' command, up to the point where the actual
#	'invoke' is issued.
#
................................................................................
    set firstOptional $pos

    set nMandatory 0
    if {$firstOptional > $firstMandatory} {

        # Make code to check length of arg list
        set nMandatory [expr {$firstOptional - $firstMandatory}]
        my va_CheckEnough $B $nMandatory

        # Make code to transfer mandatory args
        my va_UnpackMandatory $B newq $nMandatory
    }

    # Now we have the parameters that have default values.

    set j $nMandatory
    if {$nPlainParams > $firstOptional} {

        error "NOT DONE - varargs doing optional arg(s)"

        # Emit a code burst for each optional parameter to
        # check the list length and extract the parameter
        set optInfo {}
        set finishB [llength $bbcontent]
        lappend bbcontent {}
        lappend bbpred {}
        set i $firstOptional

        while {$i < $nPlainParams} {

            info default $callee [lindex $arginfo $i] defaultVal





            lassign [my va_UnpackOptional tempIndex b bb \
                         $finishB $compTemp $listLoc $lenLoc $j] \
                fromBlock argLoc
            lappend optInfo [list $fromBlock $defaultVal $argLoc]
            incr i
            incr j
        }



        # Close out the last basic block, switch to the 'finish' block
        # and emit 'phi' instructions to get the correct parameter set
        my va_FinishOptional b bb newq $finishB $optInfo

    }

................................................................................
    } else {
        error  "NOT DONE - varargs needs to check for excess args"
        my va_CheckTooMany b bb $lenLoc $compTemp $j $notokb
    }

    return $newq
}
 
# quadcode::transformer method va_UnlinkTail --
#
#	Removes the invocation sequence from a basic block in preparation
#	for rewriting it.
#
# Parameters:
#	b - Number of the basic block
#	pc - Program counter of the first instruction being deleted
#
# Results:
#	Returns the partial basic block that remains.
#
# Side effects:
#	Variable defs and uses in the invocation sequence are removed
#	from ud- and du-chains. The basic block is unlinked from its
#	successors. 

oo::define quadcode::transformer method va_UnlinkTail {b pc} {

    set bb [lindex $bbcontent $b]
    lset bbcontent $b {}
    my debug-varargs {
        puts "varargs: Split basic block $b:"
        puts "   $b:$pc: [lindex $bb $pc]"
    }

    set tail [lrange $bb $pc end]
    set bb [lreplace $bb[set bb {}] $pc end]
    lset bbcontent $b $bb
    foreach q $tail {
        if {[lindex $q 1 0] in {"temp" "var"}} {
            dict unset udchain [lindex $q 1]
        }
        foreach arg [lrange $q 2 end] {
            if {[lindex $arg 0] in {"temp" "var"}} {
                my removeUse $arg $b
            }
        }
    }
    foreach b2 [my bbsucc $b] {
        my removePred $b2 $b
    }

    return [lreplace $tail[set tail {}] 0 0]
}
 
# quadcode::transformer method va_NonExpandedArgument --
#
#	Transfer a leading non-expanded argument into a quad
#	under construction when rewriting 'invokeExpanded'
#
# Parameters:
................................................................................
            $B log-last
        }
    }

    return $mightThrow

}
 
# quadcode::transformer method va_CheckEnough --
#
#	Emits code to check for too few args passed to invokeExpanded
#
# Parameters:
#	B - Builder that is managing code for this invocation
#	result - Return value from the call
#	cfin - Input call frame to the call
#	cmd - Name of the command being invoked
#	nMandatory - Number of non-defaulted args that must be provided
#
# Results:
#	None.
#
# Side effects:
#	Emits the check, the 'wrong # args' error if needed, and generates
#	the error block if needed

oo::define quadcode::transformer method va_CheckEnough {B result cfin cmd
                                                        nMandatory} {

    error "va_CheckEnough: Not yet reached in testing"

    set compLoc [my newVarInstance {temp @toofew}]
    set lenLoc [$B gettemp arglen]

    # compare args provided to args needed
    $B emit [list gt $compLoc [list literal $nMandatory] $lenLoc]
    my debug-varargs {
        $B log-last
    }

    # jump to errb if wrong
    set errb [$B makeblock]
    $B emit [list jumpTrue [list bb $errb] $compLoc]
    my debug-varargs {
        $B log-last
    }

    # jump to okb if right
    set okb [$B makeblock]
    $B emit [list jump [list bb $okb]]
    my debug-varargs {
        $B log-last
    }

    # make code to emit 'wrong # args' error
    set wrongb [my va_EmitWrongArgs $result $cfin $cmd]

    # jump from errb to code that throws error
    $B buildin $errb
    $B emit [list jump [list bb $wrongb]]
    my debug-varargs {
        $B log-last
    }

    # return to the 'no failure' branch
    $B buildin $okb

}
 
# quadcode::transformer method va_MakeErrorCheck --
#
#	Emits code to jump to an error block if a given value is FAIL.
#
# Parameters:
#	B - Builder that is emitting code
#	val - Value that might be FAIL
#
# Results:
#	None.
#
# Side effects:
#	Emits the necessary jumpMaybe, and adds FAIL value
#	to the phi operation at the head of the error block.

oo::define quadcode::transformer method va_MakeErrorCheck {B val} {

    # Emit any required error checking when building the variable
    # argument list.
    my va_MakeErrorBlock $B
    set errorb [$B getblock error]
    set intb [$B makeblock]
    set nextb [$B makeblock]

    # Close out the current block with jumpMaybe to an intermediate
    # block and jump to the normal return
    $B emit [list jumpMaybe [list bb $intb] $val]
    my debug-varargs {
        $B log-last
    }
    $B emit [list jump [list bb $nextb]]
    my debug-varargs {
        $B log-last
    }

    # Make an intermediate block that jumps to the error block
    $B buildin $intb
    $B emit [list jump [list bb $errorb]]
    my debug-varargs {
        $B log-last
    }

    # Add phis for the error result ant the callframe to the error block
    set errorInPhi [$B gettemp error]
    $B updatephi $errorb $errorInPhi $val

    # Now continue building in the normal exit
    $B buildin $nextb
}
 
# quadcode::transformer method va_MakeErrorBlock --
#
#	Makes the block to which all the error paths in an invocation
#	sequence jump.
#
# Parameters:
#	B - Builder that is emitting code
#
# Results:
#	Returns the number of the block.
#
# Side effects:
#	Creates the block, and adds a vacuous 'phi' operation to it that
#	will hold the FAIL value from the error. The block and the result
#	of the 'phi' are both named 'error' in the builder.

oo::define quadcode::transformer method va_MakeErrorBlock {B} {

    my debug-varargs {
        puts "varargs: Create a block for error exits."
    }
    set currentb [$B curblock]
    set errorb [$B makeblock error]

    $B buildin $errorb
    set errortemp [$B maketemp error]
    $B emit [list phi $errortemp]
    my debug-varargs {
        $B log-last
    }

    $B buildin $currentb
    return
}
 
# quadcode::transformer method va_UnpackMandatory --
#
#	Unpacks the mandatory args to a proc from the list created
#	by argument expansion
#
# Parameters;
#	tempIdxVar - Variable in caller's scope containing the last
#	             allocated temporary
#	bbVar - Variable in caller's scope containing basic block content
#	newqVar - Variable in caller's scope containing the new 'invoke'
#	          quad being constructed.
#	b - Basic block number under construction
#	listLoc - Variable or temp holding the list being unpacked


#	nMandatory - Number of parameters to unpack
#
# Results:
#	None.
#
# Side effects:
#	Emits code to unpack the mandatory parameters

oo::define quadcode::transformer method va_UnpackMandatory {tempIdxVar
                                                                bbVar newqVar

                                                                b listLoc
                                                                nMandatory} {
    error "va_UnpackMandatory: Not yet refactored or reached in testing"
    upvar 1 $tempIdxVar tempIdx $bbVar bb $newqVar newq

    for {set i 0} {$i < $nMandatory} {incr i} {





        # Emit the 'listIndex' instruction for one arg. It can't fail
        # because we know we have a list

        set argTemp [list temp [incr tempIdx]]
        set argLoc [my newVarInstance $argTemp]
        my va_EmitAndTrack $b bb \
            [list listIndex $argLoc $listLoc [list literal $i]]



        # Emit the 'extractMaybe' to get the arg from the Maybe

        # result of 'listIndex'
        set argLoc2 [my newVarInstance $argTemp]
        my va_EmitAndTrack $b bb [list extractMaybe $argLoc2 $argLoc]




        # Put the extracted arg on the 'invoke' instruction
        lappend newq $argLoc2
    }


}
 
# quadcode::transformer method va_UnpackOptional --
#
#	Emits code to unpack one optional parameter in an invokeExpanded
#
# Parameters:
#	tempIdxVar - Variable holding the index of the last used temporary
#	bVar - Variable holding the current basic block number
#	bbVar - Variable holding the content of the basic block under
#	        construction
#	finishB - Basic block number of the finishing block
#	compTemp - Temporary to use for list comparisons
#	listLoc - Location where the arg list is found
#	lenLoc - Location where the list length is found
#	j - Index in the arg list of the current parameter
#
# Results:
#	Returns a two-element list giving the block number that jumps
#	to the finish if the parameter is not supplied and the
#	location of a temporary holding the unpacked value if it is.
#
# Side effects:
................................................................................
#	Emits code to unpack one value, or jump to the finish block if
#	there is nothing to unpack.

oo::define quadcode::transformer method va_UnpackOptional {tempIdxVar bVar
                                                               bbVar finishB
                                                               compTemp listLoc
                                                               lenLoc j} {
    error "va_UnpackOptional: Not yet refactored or reached in testing"
    upvar 1 $tempIdxVar tempIndex $bVar b $bbVar bb

    set pos [list literal $j]
    set compLoc [my newVarInstance $compTemp]
    set argTemp [list temp [incr tempIndex]]
    set argLoc1 [my newVarInstance $argTemp]
    set argLoc2 [my newVarInstance $argTemp]
................................................................................
    }

    # If args is the whole list, just concatenate it onto the invoke
    if {$i == 0} {
        lappend newq $listLoc
    } else {
        set argsLoc1 [$B maketemp \$args]
        $B build [list listRange $argsLoc1 $listLoc \
                      [list literal $i] {literal end}]
        my debug-varargs {
            $B log-last
        }

        set argsLoc2 [B maketemp \$args]
        $B build [list extractMaybe $argsLoc2 $argsLoc1]
        lappend newq $argsLoc2
    }


















































}
 
# quadcode::transformer method va_CheckTooMany --
#
#	Emits a codeburst to check whether an 'invokeExpanded' has
#	too many args
#
................................................................................
    lset bbcontent $b $bb

    set b $newb
    set bb {}

}
 
# quadcode::transformer method va_EmitWrongArgs --
#
#	Generates code to throw the 'wrong # args' error when needed
#
# Parameters:
#	result - Quadcode value that will hold the command result
#	cfin - Quadcode value that holds the pre-invoke callframe,
#	       or Nothing if no callframe need be produced
#	cmd - Quadcode literal with the name of the command being invoked
#
# Results:
#	None.

#
# Side effects:
#	Returns a codeburst that throws the exception



oo::define quadcode::transformer method va_EmitWrongArgs {result cfin cmd} {


    set burst {}





    set argl [info args [lindex $cmd 1]]
    set left [llength $argl]
    set sbval [list [lindex $cmd 1]]
    foreach a $argl {
        incr left -1
        if {$a eq "args" && $left == 0} {
            append sbval " ?arg ...?"
        } elseif {[info default [lindex $cmd 1] $a -]} {
            lappend sbval ?$a?
        } else {
            lappend sbval $a
        }
    }

    set msgval "wrong # args: should be \"$sbval\""
    set intres [my newVarInstance $result]


    set q [list initException $intres [list literal $msgval] \
               {literal {-errorcode {TCL WRONGARGS}}} \
               {literal 1} \
               {literal 0}]
    lappend burst $q





    set q [list extractFail $result $intres]
    lappend burst $q












    return $burst



























































































}
 
# oo::transformer method va_ConvergeErrorPath --
#
#	Converges the code for the error and normal paths after an 'invoke'.
#
# Parameters:

    if {[lindex $cmd 0] ne "literal"
        || [catch {info args [lindex $cmd 1]} arginfo]} {
        return {0 {}}
    } else {
        return [list 1 $arginfo]
    }
}
 
# quadcode::transformer method va_UnlinkTail --
#
#	Removes the invocation sequence from a basic block in preparation
#	for rewriting it.
#
# Parameters:
#	b - Number of the basic block
#	pc - Program counter of the first instruction being deleted
#
# Results:
#	Returns the partial basic block that remains.
#
# Side effects:
#	Variable defs and uses in the invocation sequence are removed
#	from ud- and du-chains. The basic block is unlinked from its
#	successors. 

oo::define quadcode::transformer method va_UnlinkTail {b pc} {

    set bb [lindex $bbcontent $b]
    lset bbcontent $b {}
    my debug-varargs {
        puts "varargs: Split basic block $b:"
        puts "   $b:$pc: [lindex $bb $pc]"
    }

    set tail [lrange $bb $pc end]
    set bb [lreplace $bb[set bb {}] $pc end]
    lset bbcontent $b $bb
    foreach q $tail {
        if {[lindex $q 1 0] in {"temp" "var"}} {
            dict unset udchain [lindex $q 1]
        }
        foreach arg [lrange $q 2 end] {
            if {[lindex $arg 0] in {"temp" "var"}} {
                my removeUse $arg $b
            }
         }
    }
    foreach b2 [my bbsucc $b] {
        my removePred $b2 $b
    }

    return [lreplace $tail[set tail {}] 0 0]
}
 
# quadcode::transformer method va_PrepareArgs --
#
#	Emits code to prepare the arguments for an 'invoke' or
#	'invokeExpanded' command, up to the point where the actual
#	'invoke' is issued.
#
................................................................................
    set firstOptional $pos

    set nMandatory 0
    if {$firstOptional > $firstMandatory} {

        # Make code to check length of arg list
        set nMandatory [expr {$firstOptional - $firstMandatory}]
        my va_CheckEnough $B $callee $nMandatory

        # Make code to transfer mandatory args
        set newq [my va_UnpackMandatory $B $newq $nMandatory]
    }

    # Now we have the parameters that have default values.

    set j $nMandatory
    if {$nPlainParams > $firstOptional} {



        # Emit a code burst for each optional parameter to
        # check the list length and extract the parameter




        set i $firstOptional

        while {$i < $nPlainParams} {
        
            info default $callee [lindex $arginfo $i] defaultVal

            my debug-varargs {
                puts "Emit length check and extraction for optional param \
                      $i: [lindex $arginfo $i] (default=$defaultVal)"
            }
            lassign [my va_UnpackOptional $B $newq $j] \

                newq fromBlock argLoc
            lappend optInfo [list $fromBlock $defaultVal $argLoc]
            incr i
            incr j
        }

        error "NOT FINISHED - Close out the optional params."

        # Close out the last basic block, switch to the 'finish' block
        # and emit 'phi' instructions to get the correct parameter set
        my va_FinishOptional b bb newq $finishB $optInfo

    }

................................................................................
    } else {
        error  "NOT DONE - varargs needs to check for excess args"
        my va_CheckTooMany b bb $lenLoc $compTemp $j $notokb
    }

    return $newq
}














































 
# quadcode::transformer method va_NonExpandedArgument --
#
#	Transfer a leading non-expanded argument into a quad
#	under construction when rewriting 'invokeExpanded'
#
# Parameters:
................................................................................
            $B log-last
        }
    }

    return $mightThrow

}
 


















































































































































# quadcode::transformer method va_UnpackMandatory --
#
#	Unpacks the mandatory args to a proc from the list created
#	by argument expansion
#
# Parameters;







#	B - Builder that is emitting quadcode
#	newq - 'invoke' instruction under construction
#	nMandatory - Number of parameters to unpack
#
# Results:
#	Returns the 'invoke' instruction with the mandatory parameters added.
#
# Side effects:
#	Emits code to unpack the mandatory parameters

oo::define quadcode::transformer method va_UnpackMandatory {B newq nMandatory} {


    set arglist [$B gettemp arglist]




    for {set i 0} {$i < $nMandatory} {incr i} {

        my debug-varargs {
            puts "varargs: transfer mandatory argument $i"
        }

        # Emit the 'listIndex' instruction for one arg. It can't fail
        # because we know we have a list

        set argtemp [$B maketemp arg$i]


        $B emit [list listIndex $argtemp $arglist [list literal $i]]
        my debug-varargs {
            $B log-last
        }


        set argloc [$B maketemp arg$i]

        $B emit [list extractMaybe $argloc $argtemp]
        my debug-varargs {
            $B log-last
        }

        # Put the extracted arg on the 'invoke' instruction
        lappend newq $argloc
    }

    return $newq
}
 
# quadcode::transformer method va_UnpackOptional --
#
#	Emits code to unpack one optional parameter in an invokeExpanded
#
# Parameters:
#	B - Builder that is emitting the invocation sequence
#	newq - 'invoke' instruction under construction
#	j - Position of the parameter being unpacked






#
# Results:
#	Returns a two-element list giving the block number that jumps
#	to the finish if the parameter is not supplied and the
#	location of a temporary holding the unpacked value if it is.
#
# Side effects:
................................................................................
#	Emits code to unpack one value, or jump to the finish block if
#	there is nothing to unpack.

oo::define quadcode::transformer method va_UnpackOptional {tempIdxVar bVar
                                                               bbVar finishB
                                                               compTemp listLoc
                                                               lenLoc j} {

    upvar 1 $tempIdxVar tempIndex $bVar b $bbVar bb

    set pos [list literal $j]
    set compLoc [my newVarInstance $compTemp]
    set argTemp [list temp [incr tempIndex]]
    set argLoc1 [my newVarInstance $argTemp]
    set argLoc2 [my newVarInstance $argTemp]
................................................................................
    }

    # If args is the whole list, just concatenate it onto the invoke
    if {$i == 0} {
        lappend newq $listLoc
    } else {
        set argsLoc1 [$B maketemp \$args]
        $B emit [list listRange $argsLoc1 $listLoc \
                      [list literal $i] {literal end}]
        my debug-varargs {
            $B log-last
        }

        set argsLoc2 [$B maketemp \$args]
        $B emit [list extractMaybe $argsLoc2 $argsLoc1]
        lappend newq $argsLoc2
    }

}
 
# quadcode::transformer method va_CheckEnough --
#
#	Emits code to check for too few args passed to invokeExpanded
#
# Parameters:
#	B - Builder that is managing code for this invocation
#	callee - Name of the invoked command
#	minLength - Minumum length of the arglist
#
# Results:
#	None.
#
# Side effects:
#	Emits the check, the 'wrong # args' error if needed, and generates
#	the error block if needed
#
# The assumption is made that the 'arglen' temporary in $B has the
# length of the 

oo::define quadcode::transformer method va_CheckEnough {B callee minLength} {

    set compLoc [my newVarInstance {temp @toofew}]
    set lenLoc [$B gettemp arglen]

    # compare args provided to args needed
    $B emit [list gt $compLoc [list literal $minLength] $lenLoc]
    my debug-varargs {
        $B log-last
    }

    # jump to a 'wrong # args' error if wrong
    set errb [my va_MakeWrongArgs $B $callee]
    $B emit [list jumpTrue [list bb $errb] $compLoc]
    my debug-varargs {
        $B log-last
    }

    # jump to okb if right
    set okb [$B makeblock]
    $B emit [list jump [list bb $okb]]
    my debug-varargs {
        $B log-last
    }

    # return to the 'no failure' branch
    $B buildin $okb

}
 
# quadcode::transformer method va_CheckTooMany --
#
#	Emits a codeburst to check whether an 'invokeExpanded' has
#	too many args
#
................................................................................
    lset bbcontent $b $bb

    set b $newb
    set bb {}

}
 
# quadcode::transformer method va_MakeWrongArgs --
#
#	Generates code to throw the 'wrong # args' error when needed
#
# Parameters:
#	B - Builder that is generating quadcode
#	callee - Name of the called procedure


#
# Results:

#	Returns the basic block number of the generated block
#
# Side effects:

#	Generates a block that creates an exception and jumps to the
#	error handler.

oo::define quadcode::transformer method va_MakeWrongArgs {B callee} {

    set wrongb [$B getblock "wrongargs"]
    if {$wrongb >= 0} {
        return $wrongb
    }
    set wrongb [$B makeblock "wrongargs"]
    set currentb [$B curblock]

    set argl [info args $callee]
    set left [llength $argl]
    set sbval [list $callee]
    foreach a $argl {
        incr left -1
        if {$a eq "args" && $left == 0} {
            append sbval " ?arg ...?"
        } elseif {[info default $callee $a -]} {
            lappend sbval ?$a?
        } else {
            lappend sbval $a
        }
    }

    set msgval "wrong # args: should be \"$sbval\""
    set intres [$B maketemp wrongargs]

    $B buildin $wrongb
    $B emit [list initException $intres [list literal $msgval] \
                 {literal {-errorcode {TCL WRONGARGS}}} \
                 {literal 1} \
                 {literal 0}]

    my debug-varargs {
        $B log-last
    }
    
    set excloc [$B maketemp wrongargs]
    $B emit [list extractFail $excloc $intres]

    my debug-varargs {
        $B log-last
    }

    set errorb [my va_MakeErrorBlock $B]
    $B emit [list jump [list bb $errorb]]

    # Add phis for the error result ant the callframe to the error block
    set errorInPhi [$B gettemp error]
    $B updatephi $errorb $errorInPhi $excloc
    
    $B buildin $currentb
    return $wrongb
    
}
 
# quadcode::transformer method va_MakeErrorCheck --
#
#	Emits code to jump to an error block if a given value is FAIL.
#
# Parameters:
#	B - Builder that is emitting code
#	val - Value that might be FAIL
#
# Results:
#	None.
#
# Side effects:
#	Emits the necessary jumpMaybe, and adds FAIL value
#	to the phi operation at the head of the error block.

oo::define quadcode::transformer method va_MakeErrorCheck {B val} {

    # Emit any required error checking when building the variable
    # argument list.
    my va_MakeErrorBlock $B
    set errorb [$B getblock error]
    set intb [$B makeblock]
    set nextb [$B makeblock]

    # Close out the current block with jumpMaybe to an intermediate
    # block and jump to the normal return
    $B emit [list jumpMaybe [list bb $intb] $val]
    my debug-varargs {
        $B log-last
    }
    $B emit [list jump [list bb $nextb]]
    my debug-varargs {
        $B log-last
    }

    # Make an intermediate block that jumps to the error block
    $B buildin $intb
    $B emit [list jump [list bb $errorb]]
    my debug-varargs {
        $B log-last
    }

    # Add phis for the error result ant the callframe to the error block
    set errorInPhi [$B gettemp error]
    $B updatephi $errorb $errorInPhi $val

    # Now continue building in the normal exit
    $B buildin $nextb
}
 
# quadcode::transformer method va_MakeErrorBlock --
#
#	Makes the block to which all the error paths in an invocation
#	sequence jump.
#
# Parameters:
#	B - Builder that is emitting code
#
# Results:
#	Returns the number of the block.
#
# Side effects:
#	Creates the block, and adds a vacuous 'phi' operation to it that
#	will hold the FAIL value from the error. The block and the result
#	of the 'phi' are both named 'error' in the builder.

oo::define quadcode::transformer method va_MakeErrorBlock {B} {

    my debug-varargs {
        puts "varargs: Create a block for error exits."
    }
    set errorb [$B getblock error]
    if {$errorb >= 0} {
        return $errorb
    }
    
    set currentb [$B curblock]
    set errorb [$B makeblock error]

    $B buildin $errorb
    set errortemp [$B maketemp error]
    $B emit [list phi $errortemp]
    my debug-varargs {
        $B log-last
    }

    $B buildin $currentb
    return
}
 
# oo::transformer method va_ConvergeErrorPath --
#
#	Converges the code for the error and normal paths after an 'invoke'.
#
# Parameters: