# Results:
    #	The new dictionary value.

    method dictUnset(STRING,STRING) {dict key ec {name ""}} {
	my call ${tcl.dict.unset1} [list $dict $key $ec] $name
    }

    # Builder:directAppend(STRING,STRING) --
    #
    #	Append a value to a variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation
    #	('directAppend').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.


    method directAppend(STRING,STRING) {varname value ec {name ""}} {

	my call ${tcl.direct.append} [list $varname {} $value $ec] $name

    }

    # Builder:directArrayAppend(STRING,STRING,STRING) --
    #
    #	Append a value to an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation
    #	('directArrayAppend').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.


    method directArrayAppend(STRING,STRING,STRING) {varname elem value ec {name ""}} {

	my call ${tcl.direct.append} [list $varname $elem $value $ec] $name

    }

    # Builder:directExists(STRING) --
    #
    #	Test if a variable exists; the variable should be referred to by a
    #	fully-qualified name. Quadcode implementation ('directExists').
    #
    # Parameters:


    #	varname -
    #		The variable name as an LLVM value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A ZEROONE that indicates whether the variable is set.

    method directExists(STRING) {varname {name ""}} {
	my call ${tcl.direct.exists} [list $varname {}] $name
    }

    # Builder:directArrayExists(STRING,STRING) --
    #
    #	Test if an array variable exists; the variable should be referred to
    #	by a fully-qualified name. Quadcode implementation
    #	('directArrayExists').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A ZEROONE that indicates whether the variable is set.


    method directArrayExists(STRING,STRING) {varname elem {name ""}} {
	my call ${tcl.direct.exists} [list $varname $elem] $name
    }

    # Builder:directGet(STRING) --
    #
    #	Read the value of a variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation ('directGet').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The contents of the variable.

    method directGet(STRING) {varname ec {name ""}} {
	my call ${tcl.direct.get} [list $varname {} $ec] $name

    }

    # Builder:directArrayGet(STRING,STRING) --
    #
    #	Read the value of an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation
    #	('directArrayGet').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The contents of the variable.


    method directArrayGet(STRING,STRING) {varname elem ec {name ""}} {


	my call ${tcl.direct.get} [list $varname $elem $ec] $name

    }

    # Builder:directLappend(STRING,STRING) --
    #
    #	Append a value to a list in a variable, which should be referred to by
    #	a fully-qualified name. NOTE: this operation can fail because of
    #	traces so it produces a STRING FAIL. Quadcode implementation
    #	('directLappend').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.


    method directLappend(STRING,STRING) {varname value ec {name ""}} {

	my call ${tcl.direct.lappend} [list $varname {} $value $ec] $name

    }

    # Builder:directArrayLappend(STRING,STRING,STRING) --
    #
    #	Append a value to a list in an array variable, which should be
    #	referred to by a fully-qualified name. NOTE: this operation can fail
    #	because of traces so it produces a STRING FAIL. Quadcode
    #	implementation ('directArrayLappend').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.


    method directArrayLappend(STRING,STRING,STRING) {varname elem value ec {name ""}} {

	my call ${tcl.direct.lappend} [list $varname $elem $value $ec] $name

    }

    # Builder:directLappendList(STRING,STRING) --
    #
    #	Append the elements of a list to a list in a variable, which should be
    #	referred to by a fully-qualified name. NOTE: this operation can fail
    #	because of traces so it produces a STRING FAIL. Quadcode
    #	implementation ('directLappendList').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	value -	The list of values to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.


    method directLappendList(STRING,STRING) {varname value ec {name ""}} {

	my call ${tcl.direct.lappendList} [list $varname {} $value $ec] $name

    }

    # Builder:directLappendList(STRING,STRING,STRING) --
    #
    #	Append the elements of a list to a list in a variable, which should be
    #	referred to by a fully-qualified name. NOTE: this operation can fail
    #	because of traces so it produces a STRING FAIL. Quadcode
    #	implementation ('directLappendList').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	value -	The list of values to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.


    method directArrayLappendList(STRING,STRING,STRING) {varname elem value ec {name ""}} {

	my call ${tcl.direct.lappendList} [list $varname $elem $value $ec] $name

    }

    # Builder:directSet(STRING,STRING) --
    #
    #	Set the value of a variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation ('directSet').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directSet(STRING,STRING) {varname value ec {name ""}} {

	my call ${tcl.direct.set} [list $varname {} $value $ec] $name

    }

    # Builder:directArraySet(STRING,STRING,STRING) --
    #
    #	Set the value of an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation
    #	('directArraySet').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.


    method directArraySet(STRING,STRING,STRING) {varname elem value ec {name ""}} {


	my call ${tcl.direct.set} [list $varname $elem $value $ec] $name

    }

    # Builder:directUnset(STRING,INT) --
    #
    #	Unset a variable, which should be referred to by a fully-qualified
    #	name. NOTE: this operation can fail because of traces so it produces a
    #	ZEROONE FAIL (with meaningless value when not failing). Quadcode
    #	implementation ('directUnset').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	flag -	Whether failures are allowed, as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the unset was successful.

    method directUnset(STRING,INT) {varname flag ec {name ""}} {

	my call ${tcl.direct.unset} [list $varname {} $flag $ec] $name

    }

    # Builder:directArrayUnset(STRING,STRING,INT) --
    #
    #	Unset an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a ZEROONE FAIL (with meaningless value when not
    #	failing). Quadcode implementation ('directArrayUnset').
    #
    # Parameters:

    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	flag -	Whether failures are allowed, as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the unset was successful.


    method directArrayUnset(STRING,STRING,INT) {varname elem flag ec {name ""}} {

	my call ${tcl.direct.unset} [list $varname $elem $flag $ec] $name

    }

    # Builder:directIsArray(STRING) --
    #
    #	Tests if the variable whose name we are given is an array. NOTE: this
    #	operation can fail because of traces so it produces a BOOL FAIL.
    #	Quadcode implementation ('directIsArray').
    #

    # Results:
    #	The new dictionary value.

    method dictUnset(STRING,STRING) {dict key ec {name ""}} {
	my call ${tcl.dict.unset1} [list $dict $key $ec] $name
    }

    # Builder:directAppend(CALLFRAME,STRING,STRING) --
    #
    #	Append a value to a variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation
    #	('directAppend').
    #
    # Parameters:
    #	cf -	The callframe where non-fully-qualified variable names resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directAppend(CALLFRAME,STRING,STRING) \
	{cf varname value ec {name ""}} {
	    set result [my call ${tcl.direct.append}
			[list $varname {} $value $ec] $name]
	    return [my frame.pack $cf $result]
    }

    # Builder:directArrayAppend(CALLFRAME,STRING,STRING,STRING) --
    #
    #	Append a value to an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation
    #	('directArrayAppend').
    #
    # Parameters:
    #	cf -	The callframe where non-fully-qualified names are resolved
    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directArrayAppend(CALLFRAME,STRING,STRING,STRING) \
	{cf varname elem value ec {name ""}} {
	    set result [my call ${tcl.direct.append} \
			    [list $varname $elem $value $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directExists(STRING) --
    #
    #	Test if a variable exists; the variable should be referred to by a
    #	fully-qualified name. Quadcode implementation ('directExists').
    #
    # Parameters:
    #	cf -    The callframe in which the variable is expected to appear, if
    #	        the variable name is unqualified
    #	varname -
    #		The variable name as an LLVM value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A ZEROONE that indicates whether the variable is set.

    method directExists(CALLFRAME,STRING) {cf varname {name ""}} {
	my call ${tcl.direct.exists} [list $varname {}] $name
    }

    # Builder:directArrayExists(CALLFRAME,STRING,STRING) --
    #
    #	Test if an array variable exists; the variable should be referred to
    #	by a fully-qualified name. Quadcode implementation
    #	('directArrayExists').
    #
    # Parameters:
    #	cf -	The callname where a non-fully-qualified varname is resolved
    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A ZEROONE that indicates whether the variable is set.

    method directArrayExists(CALLFRAME,STRING,STRING) {cf varname
	                                               elem {name ""}} {
	my call ${tcl.direct.exists} [list $varname $elem] $name
    }

    # Builder:directGet(CALLFRAME.STRING) --
    #
    #	Read the value of a variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation ('directGet').
    #
    # Parameters:
    #	cf -    The callframe to use for other than fully-qualified varnames
    #	varname -
    #		The variable name as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The contents of the variable.

    method directGet(CALLFRAME,STRING) {cf varname ec {name ""}} {
	set result [my call ${tcl.direct.get} [list $varname {} $ec] $name]
	return [my frame.pack $cf $result]
    }

    # Builder:directArrayGet(STRING,STRING) --
    #
    #	Read the value of an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation
    #	('directArrayGet').
    #
    # Parameters:
    #   cf - Callframe in which non-fully-qualified names are resolved
    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The contents of the variable.

    method directArrayGet(CALLFRAME,STRING,STRING) \
	{cf varname elem ec {name ""}} \
	{
	    set result [my call ${tcl.direct.get} \
			    [list $varname $elem $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directLappend(CALLFRAME,STRING,STRING) --
    #
    #	Append a value to a list in a variable, which should be referred to by
    #	a fully-qualified name. NOTE: this operation can fail because of
    #	traces so it produces a STRING FAIL. Quadcode implementation
    #	('directLappend').
    #
    # Parameters:
    #	cf -	Callframe where non-fully-qualified variables resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directLappend(CALLFRAME,STRING,STRING) \
	{cf varname value ec {name ""}} {
	    set result [my call ${tcl.direct.lappend} \
			    [list $varname {} $value $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directArrayLappend(CALLFRAME,STRING,STRING,STRING) --
    #
    #	Append a value to a list in an array variable, which should be
    #	referred to by a fully-qualified name. NOTE: this operation can fail
    #	because of traces so it produces a STRING FAIL. Quadcode
    #	implementation ('directArrayLappend').
    #
    # Parameters:
    #	cf -	Callframe where non-fully-qualified variables resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directArrayLappend(CALLFRAME,STRING,STRING,STRING) \
	{cf varname elem value ec {name ""}} {
	    set result [my call ${tcl.direct.lappend} \
			    [list $varname $elem $value $ec] $name]
	    return [my frame.pack $cf $result]
    }

    # Builder:directLappendList(CALLFRAME,STRING,STRING) --
    #
    #	Append the elements of a list to a list in a variable, which should be
    #	referred to by a fully-qualified name. NOTE: this operation can fail
    #	because of traces so it produces a STRING FAIL. Quadcode
    #	implementation ('directLappendList').
    #
    # Parameters:
    #	cf -	Callframe where non-fully-qualified variables resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	value -	The list of values to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directLappendList(CALLFRAME,STRING,STRING) \
	{cf varname value ec {name ""}} {
	    set result [my call ${tcl.direct.lappendList} \
			    [list $varname {} $value $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directLappendList(CALLFRAME,STRING,STRING,STRING) --
    #
    #	Append the elements of a list to a list in a variable, which should be
    #	referred to by a fully-qualified name. NOTE: this operation can fail
    #	because of traces so it produces a STRING FAIL. Quadcode
    #	implementation ('directLappendList').
    #
    # Parameters:
    #	cf -	Callframe where non-fully-qualified names should resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	value -	The list of values to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directArrayLappendList(CALLFRAME,STRING,STRING,STRING) \
	{cf varname elem value ec {name ""}} {
	    set result [my call ${tcl.direct.lappendList} \
			    [list $varname $elem $value $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directSet(CALLFRAME,STRING,STRING) --
    #
    #	Set the value of a variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a STRING FAIL. Quadcode implementation ('directSet').
    #
    # Parameters:
    #	cf -    The callframe to use for other than fully-qualified varnames
    #	varname -
    #		The variable name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directSet(CALLFRAME,STRING,STRING) {cf varname value ec {name ""}} {
	set result [my call ${tcl.direct.set} \
			[list $varname {} $value $ec] $name]
	return [my frame.pack $cf $result]
    }

    # Builder:directArraySet(CALLFRAME,STRING,STRING,STRING) --
    #
    #	Set the value of an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a CALLFRAME STRING FAIL. Quadcode implementation
    #	('directArraySet').
    #
    # Parameters:
    #	cf -    The callframe in which non-fully-qualified names should resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new contents of the variable.

    method directArraySet(CALLFRAME,STRING,STRING,STRING) \
	{cf varname elem value ec {name ""}} \
	{
	    set result [my call ${tcl.direct.set} \
			    [list $varname $elem $value $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directUnset(CALLFRAME,STRING,INT) --
    #
    #	Unset a variable, which should be referred to by a fully-qualified
    #	name. NOTE: this operation can fail because of traces so it produces a
    #	ZEROONE FAIL (with meaningless value when not failing). Quadcode
    #	implementation ('directUnset').
    #
    # Parameters:
    #	cf -	Callframe in which non-fully-qualified names should resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	flag -	Whether failures are allowed, as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the unset was successful.

    method directUnset(CALLFRAME,STRING,INT) {cf varname flag ec {name ""}} {
	set result [my call ${tcl.direct.unset} \
			[list $varname {} $flag $ec] $name]
	return [my frame.pack $cf $result]
    }

    # Builder:directArrayUnset(CALLFRAME,STRING,STRING,INT) --
    #
    #	Unset an array variable, which should be referred to by a
    #	fully-qualified name. NOTE: this operation can fail because of traces
    #	so it produces a ZEROONE FAIL (with meaningless value when not
    #	failing). Quadcode implementation ('directArrayUnset').
    #
    # Parameters:
    #	cf -	Callframe in which non-fully-qualified names should resolve
    #	varname -
    #		The variable name as an LLVM value reference.
    #	elem -	The element name as an LLVM value reference.
    #	flag -	Whether failures are allowed, as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the unset was successful.

    method directArrayUnset(CALLFRAME,STRING,STRING,INT) \
	{cf varname elem flag ec {name ""}} {
	    set result [my call ${tcl.direct.unset} \
			    [list $varname $elem $flag $ec] $name]
	    return [my frame.pack $cf $result]
	}

    # Builder:directIsArray(STRING) --
    #
    #	Tests if the variable whose name we are given is an array. NOTE: this
    #	operation can fail because of traces so it produces a BOOL FAIL.
    #	Quadcode implementation ('directIsArray').
    #

		    set srcs [my ConvertIndices 0 strlen 1 2]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in [my ValueTypes $tgt]} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}
		"directGet" - "directSet" - "directAppend" - "directLappend" -
		"directLappendList" - "directUnset" -
		"directArrayGet" - "directArraySet" - "directArrayAppend" -
		"directArrayLappend" - "directArrayLappendList" -
		"directArrayUnset" - "directIsArray" - "directMakeArray" -
		"regexp" - "listLength" -
		"listIn" - "listNotIn" - "dictIterStart" -
		"dictAppend" - "dictIncr" - "dictLappend" - "dictSize" -
		"div" - "expon" - "mod" - "verifyList" -
		"dictGetOrNexist" - "dictSetOrUnset" {
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
................................................................................
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in [my ValueTypes $tgt]} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}

















		"listAppend" - "listConcat" - "listRange" {
		    set srcs [lassign $l opcode tgt]
		    set src1 [lindex $srcs 0]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    if {consumed($src1, $pc + 1)} {

		    set srcs [my ConvertIndices 0 strlen 1 2]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in [my ValueTypes $tgt]} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}




		"directIsArray" - "directMakeArray" -
		"regexp" - "listLength" -
		"listIn" - "listNotIn" - "dictIterStart" -
		"dictAppend" - "dictIncr" - "dictLappend" - "dictSize" -
		"div" - "expon" - "mod" - "verifyList" -
		"dictGetOrNexist" - "dictSetOrUnset" {
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
................................................................................
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in [my ValueTypes $tgt]} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}
		"directGet" - "directSet" -
		"directArrayGet" - "directArraySet" -
		"directAppend" - "directLappend" -
		"directLappendList" -
		"directArrayAppend" - "directArrayLappend" -
		"directArrayLappendList" -
		"directUnset" -	"directArrayUnset"
		{
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    set resNoCF [$b frame.value $res]
		    my SetErrorLine $errorCode [$b maybe $resNoCF]
		    my StoreResult $tgt $res
		}
		"listAppend" - "listConcat" - "listRange" {
		    set srcs [lassign $l opcode tgt]
		    set src1 [lindex $srcs 0]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    if {consumed($src1, $pc + 1)} {

#		deleted).
#
# Public properties:
#	none (but see LLVMBuilder class).

oo::class create Builder {
    superclass LLVMBuilder
    variable TypeConversions

    constructor {module {builder ""}} {
	next $module $builder

	# The auto-widening type conversions. These are used to generate extra
	# methods on the fly. Note that the values for each of these keys is a
	# script that is evaluated in the MakeTypecastWrapper method.
................................................................................
		    [string map [list @b1 [list $b1]] {
			set v [lindex $f 0]
			append body1 \; [string map [list @v [list $v]] @b1]
			append body2 { } \$ [lindex $f 0]
		    }]]
	}

	# Insert the do-nothing conversions; these are generated to ensure
	# that they always exist
	set typepairs [dict keys $TypeConversions]
	set SpecialTypes {
	    ARRAY {ARRAY STRING} {NEXIST ARRAY} {NEXIST ARRAY STRING}
	    DICTFOR FOREACH
	}
	foreach type $SpecialTypes {
	    lappend typepairs [list $type $type]
	}
	foreach pair $typepairs {
	    foreach type $pair {
		set key [list $type $type]
		if {![dict exists $TypeConversions $key]} {
		    dict set TypeConversions $key \
			{append body2 { $} [lindex $f 0]}
		}
	    }
	}
    }

    # Builder:unknown --
    #
    #	Interceptor for method calls that are not already present. Delegates
    #	the test for whether we want to take action on this to the
    #	'MakeTypecastWrapper' method; if that returns true, we *replace* this
................................................................................
	# necessary, provided there is a way of generating the instruction
	# with DOUBLE in the first place.

	# First, extract the type signature that we're trying to generate.
	if {![regexp {^([^()]+)\(([\w, ]+)\)$} $signature -> name types]} {
	    return 0
	}
	set types [split $types ,]


	# The order of this determines the order we check them in



	# Search the space of possible conversions for ones that are legal,
	# and compute the cost of each.
	set clist [dict keys $TypeConversions]
	set mapped {}

	for {set i 0} {$i < [llength $clist]**[llength $types]} {incr i} {
	    set types2 {}
	    set cvts {}
	    set j $i








	    set thiscost 0
	    set legal true
	    foreach t $types {
		set c [lindex $clist [expr {$j % [llength $clist]}]]
		set j [expr {$j / [llength $clist]}]
		if {$t ne [lindex $c 0]} {








		    set legal false

		    break
		}
		lappend types2 [lindex $c 1]
		set c [dict get $TypeConversions $c]
		lappend cvts $c



		incr thiscost [string length $c]

	    }
	    if {!$legal} {
		continue
	    }
	    set n ${name}([join $types2 ,])
	    if {$n eq $signature} continue
	    if {$n in [info class methods [self class]]} {
		lappend mapped $thiscost $n $cvts
	    }
	}

	# Select the cheapest conversion and generate the method that uses it.
	set num [llength $types]
	foreach {- n cvts} [lsort -stride 3 -integer -index 0 $mapped] {
	    set formals [lindex [info class definition [self class] $n] 0]
	    set body1 "set {string casts} {}"
	    set body2 ""
	    foreach c $cvts t $types f [lrange $formals 0 [expr {$num-1}]] {
		eval $c
	    }

#		deleted).
#
# Public properties:
#	none (but see LLVMBuilder class).

oo::class create Builder {
    superclass LLVMBuilder
    variable TypeConversions DefaultTypeConversion

    constructor {module {builder ""}} {
	next $module $builder

	# The auto-widening type conversions. These are used to generate extra
	# methods on the fly. Note that the values for each of these keys is a
	# script that is evaluated in the MakeTypecastWrapper method.
................................................................................
		    [string map [list @b1 [list $b1]] {
			set v [lindex $f 0]
			append body1 \; [string map [list @v [list $v]] @b1]
			append body2 { } \$ [lindex $f 0]
		    }]]
	}

	# The type "conversion" operation used as a no-op














	set DefaultTypeConversion {append body2 { $} [lindex $f 0]}



    }

    # Builder:unknown --
    #
    #	Interceptor for method calls that are not already present. Delegates
    #	the test for whether we want to take action on this to the
    #	'MakeTypecastWrapper' method; if that returns true, we *replace* this
................................................................................
	# necessary, provided there is a way of generating the instruction
	# with DOUBLE in the first place.

	# First, extract the type signature that we're trying to generate.
	if {![regexp {^([^()]+)\(([\w, ]+)\)$} $signature -> name types]} {
	    return 0
	}
	set types [split $types ","]
	set num [llength $types]


	# Get the type signatures we could go to
	set methods [info class methods [self class]]

	# Search the space of possible conversions for ones that are legal,
	# and compute the cost of each.

	set mapped {}
	foreach targetinfo $methods {
	    if {![regexp {^([^()]+)\(([\w, ]+)\)$} $targetinfo \
		      -> tname ttypes]} {
		continue

	    }
	    if {$name ne $tname} {
		continue
	    }
	    set ttypes [split $ttypes ","]
	    if {[llength $types] != [llength $ttypes]} {
		continue
	    }
	    set thiscost 0
	    set legal true




	    set cvts [lmap st $types tt $ttypes {
		if {$st eq $tt} {
		    # No-conversion is always legal and always very cheap
		    set c $DefaultTypeConversion
		} else {
		    # Look up if we have a conversion
		    set typepair [list $st $tt]
		    if {![dict exists $TypeConversions $typepair]} {
			set legal false
			# Continue the outer loop
			break
		    }

		    set c [dict get $TypeConversions $typepair]

		}
		# The cost of a conversion is just its length. That is WRONG,
		# but approximates the real cost.
		incr thiscost [string length $c]
		string cat $c
	    }]
	    if {$legal} {





		lappend mapped $thiscost $targetinfo $cvts
	    }
	}

	# Select the cheapest conversion and generate the method that uses it.

	foreach {- n cvts} [lsort -stride 3 -integer -index 0 $mapped] {
	    set formals [lindex [info class definition [self class] $n] 0]
	    set body1 "set {string casts} {}"
	    set body2 ""
	    foreach c $cvts t $types f [lrange $formals 0 [expr {$num-1}]] {
		eval $c
	    }

    linesearch::colinear
    linesearch::sameline
    linesearch::getAllLines1
    linesearch::getAllLines2
    regexptest::*
    vartest::*
    nsvartest::*


    directtest::*



    upvar0
    upvar0a
    upvartest0::*
    upvartest1::*
    upvartest2::*
    flightawarebench::*
    hash::*

    linesearch::colinear
    linesearch::sameline
    linesearch::getAllLines1
    linesearch::getAllLines2
    regexptest::*
    vartest::*
    nsvartest::*
    directtest::init directtest::accum directtest::summarize
    directtest::check
    directtest::ary1
    directtest::ary2 directtest::ary3
    directtest::ary4 directtest::ary5
    directtest::alias
    upvar0
    upvar0a
    upvartest0::*
    upvartest1::*
    upvartest2::*
    flightawarebench::*
    hash::*

		my quads copy $res $inval
	    }
	    incrStkImm {
		set var [list temp [incr depth -1]]
		set delta [list literal [lindex $insn 1]]
		# TODO: This assumes we're dealing with qualified names!
		set val {temp opd2}
		my error-quads $pc directGet $val $var
		my generate-arith-domain-check $pc incr $val $delta
		my quads purify {temp opd0} $val
		my quads purify {temp opd1} $delta
		my quads add $val {temp opd0} {temp opd1}

		my error-quads $pc directSet $var $var $val
	    }
	    incrStk {
		set delta [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		set val {temp opd2}
		my error-quads $pc directGet $val $var
		my generate-arith-domain-check $pc incr $val $delta
		my quads purify {temp opd0} $val
		my quads purify {temp opd1} $delta
		my quads add $val {temp opd0} {temp opd1}

		my error-quads $pc directSet $var $var $val
	    }
	    incrArrayStkImm {
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		set delta [list literal [lindex $insn 1]]
		# TODO: This assumes we're dealing with qualified names!
		set val {temp opd2}
		my error-quads $pc directArrayGet $val $var $elem
		my generate-arith-domain-check $pc incr $val $delta
		my quads purify {temp opd0} $val
		my quads purify {temp opd1} $delta
		my quads add $val {temp opd0} {temp opd1}
		my error-quads $pc directArraySet $var $var $elem $val
	    }
	    incrArrayStk {
		set delta [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		set val {temp opd2}
		my error-quads $pc directArrayGet $val $var $elem
		my generate-arith-domain-check $pc incr $val $delta
		my quads purify {temp opd0} $val
		my quads purify {temp opd1} $delta
		my quads add $val {temp opd0} {temp opd1}
		my error-quads $pc directArraySet $var $var $elem $val
	    }
	    appendStk {
		set value [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my error-quads $pc directAppend $var $var $value
	    }
	    appendArrayStk {
		set value [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!

		my error-quads $pc directArrayAppend $var $var $elem $value
	    }
	    lappendStk {
		set value [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		# TODO: Typecheck: need list in $var
		my error-quads $pc directLappend $var $var $value
	    }
	    lappendListStk {
		set listvalue [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		# TODO: Typecheck: need lists in $var and $listvalue

		my error-quads $pc directLappendList $var $var $listvalue
	    }
	    lappendArrayStk {
		set value [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		# TODO: Typecheck: need list in $var

		my error-quads $pc directArrayLappend $var $var $elem $value
	    }
	    lappendListArrayStk {
		set listvalue [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		# TODO: Typecheck: need lists in $var and $listvalue
		my error-quads $pc \
		    directArrayLappendList $var $var $elem $listvalue
	    }
	    existStk {
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my quads directExists $var $var
	    }
	    existArrayStk {
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my quads directArrayExists $var $var $elem
	    }
	    loadStk {
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my error-quads $pc directGet $var $var
	    }
	    loadArrayStk {
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my error-quads $pc directArrayGet $var $var $elem
	    }
	    storeStk {
		set value [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!

		my error-quads $pc directSet $var $var $value
	    }
	    storeArrayStk {
		set value [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!

		my error-quads $pc directArraySet $var $var $elem $value
	    }
	    unsetStk {
		set flags [list literal [lindex $insn 1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!

		my error-quads $pc directUnset {temp opd0} $var $flags
	    }
	    unsetArrayStk {
		set flags [list literal [lindex $insn 1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!

		my error-quads $pc directArrayUnset {temp opd0} $var $elem $flags
	    }
	    dictGet {
		set idxNum [lindex $insn 1]
		set q {}
		for {set i 0} {$i < $idxNum} {incr i} {
		    # NOTE: Reversed
		    lappend q [list temp [incr depth -1]]
................................................................................
				 ? [set $exceptionField]
				 : $catch
			     }]
	    }
	}
	return $to_pc
    }






































# generate-jump --
#
#	Generates a jump instruction and appends it to the list of quadcodes
#	being built. Do not call from anywhere other than bytecode-to-quads!
#
#	Example uses:

		my quads copy $res $inval
	    }
	    incrStkImm {
		set var [list temp [incr depth -1]]
		set delta [list literal [lindex $insn 1]]
		# TODO: This assumes we're dealing with qualified names!
		set val {temp opd2}
		my generate-callframe-op $pc directGet $val $var
		my generate-arith-domain-check $pc incr $val $delta
		my quads purify {temp opd0} $val
		my quads purify {temp opd1} $delta
		my quads add $val {temp opd0} {temp opd1}
		my generate-callframe-op $pc directSet $var $var $val
		# WAS: my error-quads $pc directSet $var $var $val
	    }
	    incrStk {
		set delta [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		set val {temp opd2}
		my generate-callframe-op $pc directGet $val $var
		my generate-arith-domain-check $pc incr $val $delta
		my quads purify {temp opd0} $val
		my quads purify {temp opd1} $delta
		my quads add $val {temp opd0} {temp opd1}
		my generate-callframe-op $pc directSet $var $var $val
		# WAS: my error-quads $pc directSet $var $var $val
	    }
	    incrArrayStkImm {
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		set delta [list literal [lindex $insn 1]]
		# TODO: This assumes we're dealing with qualified names!
		set val {temp opd2}
		my generate-callframe-op $pc directArrayGet $val $var $elem
		my generate-arith-domain-check $pc incr $val $delta
		my quads purify {temp opd0} $val
		my quads purify {temp opd1} $delta
		my quads add $val {temp opd0} {temp opd1}
		my generate-callframe-op $pc directArraySet $var $var $elem $val
	    }
	    incrArrayStk {
		set delta [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		set val {temp opd2}
		my generate-callframe-op $pc directArrayGet $val $var $elem
		my generate-arith-domain-check $pc incr $val $delta
		my quads purify {temp opd0} $val
		my quads purify {temp opd1} $delta
		my quads add $val {temp opd0} {temp opd1}
		my generate-callframe-op $pc directArraySet $var $var $elem $val
	    }
	    appendStk {
		set value [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op $pc directAppend $var $var $value
	    }
	    appendArrayStk {
		set value [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op \
		    $pc directArrayAppend $var $var $elem $value
	    }
	    lappendStk {
		set value [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		# TODO: Typecheck: need list in $var
		my generate-callframe-op $pc directLappend $var $var $value
	    }
	    lappendListStk {
		set listvalue [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		# TODO: Typecheck: need lists in $var and $listvalue
		my generate-callframe-op \
		    $pc directLappendList $var $var $listvalue
	    }
	    lappendArrayStk {
		set value [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		# TODO: Typecheck: need list in $var
		my generate-callframe-op \
		    $pc directArrayLappend $var $var $elem $value
	    }
	    lappendListArrayStk {
		set listvalue [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		# TODO: Typecheck: need lists in $var and $listvalue
		my generate-callframe-op $pc \
		    directArrayLappendList $var $var $elem $listvalue
	    }
	    existStk {
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my quads directExists $var {temp @callframe} $var
	    }
	    existArrayStk {
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my quads directArrayExists $var {temp @callframe} $var $elem
	    }
	    loadStk {
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op $pc directGet $var $var
	    }
	    loadArrayStk {
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op $pc directArrayGet $var $var $elem
	    }
	    storeStk {
		set value [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op $pc directSet $var $var $value
		# WAS: my error-quads $pc directSet $var $var $value
	    }
	    storeArrayStk {
		set value [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op \
		    $pc directArraySet $var $var $elem $value
	    }
	    unsetStk {
		set flags [list literal [lindex $insn 1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op $pc \
		    directUnset {temp opd0} $var $flags
	    }
	    unsetArrayStk {
		set flags [list literal [lindex $insn 1]]
		set elem [list temp [incr depth -1]]
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my generate-callframe-op $pc directArrayUnset \
		    {temp opd0} $var $elem $flags
	    }
	    dictGet {
		set idxNum [lindex $insn 1]
		set q {}
		for {set i 0} {$i < $idxNum} {incr i} {
		    # NOTE: Reversed
		    lappend q [list temp [incr depth -1]]
................................................................................
				 ? [set $exceptionField]
				 : $catch
			     }]
	    }
	}
	return $to_pc
    }

# generate-callframe-op --
#
#	Generates an operation such as 'directSet' that returns CALLFRAME
#	FAIL STRING, and the necessary gubbins to extract the results.
#
# Parameters:
#	pc - Program counter in the bytecode corresponding to the
#	     program location being compiler
#	opcode - Opcode to be generated
#	result - Result where the STRING operation is to be stored after
#	         callframe and failure status are extracted.
#	args - Remaining arguments for the generated instruction. The callframe
#	       will be an implied first argument.
#
# Results:
#	None.
#
# Side effects:
#	Generates a seqquence like:
#		directSet callframeTemp callframeIn varName value
#		retrieveResult exceptionAndResult callframeTemp
#		extractCallFrame callframeOut callframeTemp
#		jumpMaybe catchBlock exceptionAndResult
#		extractMaybe resultVar exceptionAndResult.

oo::define quadcode::transformer method generate-callframe-op {pc opcode
							       result args} {
    my quads $opcode {temp @callframe} {temp @callframe} {*}$args
    my quads retrieveResult {temp @exception} {temp @callframe}
    my quads extractCallFrame {temp @callframe} {temp @callframe}
    my generate-jump [my exception-target $pc catch] maybe {temp @exception}
    my quads extractMaybe $result {temp @exception}

    return
}


# generate-jump --
#
#	Generates a jump instruction and appends it to the list of quadcodes
#	being built. Do not call from anywhere other than bytecode-to-quads!
#
#	Example uses:

	    set inty [typeOfOperand $types [lindex $q 2]]
	    return [expr {($inty & $CALLFRAME) | $FAIL | $STRING}]
	}
	callFrameNop - startCatch {
	    return $CALLFRAME
	}
	nsupvar - upvar - variable {
	    return [expr {$CALLFRAME | $BOOL | $FAIL}]
	}
	retrieveResult {
	    # Pull from the callframe of the earlier 'invoke'
	    return [expr {[typeOfOperand $types [lindex $q 2]] & ~$CALLFRAME}]
	}
	extractCallFrame {
	    # Trim the non-callframe part
................................................................................
	}
	resolveCmd {
	    return $STRING
	}
	originCmd - frameArgs {
	    return [expr {$STRING | $FAIL}]
	}
	directGet - directSet - directAppend - directLappend -
	directLappendList - directArrayGet - directArraySet -
	directArrayAppend - directArrayLappend - directArrayLappendList {
	    # Can't assume more; these may be touching traced variables
	    return [expr {$STRING | $FAIL}]






	}
	directExists - directArrayExists {
	    return $BOOL
	}
	directUnset - directArrayUnset - directIsArray - directMakeArray {
	    return [expr {$BOOL | $FAIL}]
	}
	procLeave {
	    # Produces a pure FAIL
	    return $FAIL
	}
	default {
	    error "Cannot infer type of result of $q"

	    set inty [typeOfOperand $types [lindex $q 2]]
	    return [expr {($inty & $CALLFRAME) | $FAIL | $STRING}]
	}
	callFrameNop - startCatch {
	    return $CALLFRAME
	}
	nsupvar - upvar - variable {
	    return [expr {$CALLFRAME | $ZEROONE | $FAIL}]
	}
	retrieveResult {
	    # Pull from the callframe of the earlier 'invoke'
	    return [expr {[typeOfOperand $types [lindex $q 2]] & ~$CALLFRAME}]
	}
	extractCallFrame {
	    # Trim the non-callframe part
................................................................................
	}
	resolveCmd {
	    return $STRING
	}
	originCmd - frameArgs {
	    return [expr {$STRING | $FAIL}]
	}
	directGet - directSet - directArrayGet - directArraySet -
	directAppend - directLappend - directLappendList -
	directArrayAppend - directArrayLappend - directArrayLappendList {
	    # Can't assume more; these may be touching traced variables
	    return [expr {$CALLFRAME | $STRING | $FAIL}]
	}
	directUnset - directArrayUnset {
	    # may be touching traced variables, and may fail but does not
	    # return a direct result. Say that they return a boolean because
	    # the code issuer wants everything to return a value.
	    return [expr {$CALLFRAME | $FAIL | $ZEROONE}]
	}
	directExists - directArrayExists {
	    return $BOOL
	}
	directIsArray - directMakeArray {
	    return [expr {$ZEROONE | $FAIL}]
	}
	procLeave {
	    # Produces a pure FAIL
	    return $FAIL
	}
	default {
	    error "Cannot infer type of result of $q"