foreach bb $bbcontent {
	if {[lsearch -exact -index 0 $bb upvar] >= 0} {
	    return 1
	}
    }
    return 0
}

# quadcode::transformer method callframeMotion --
#
#	Adds callframe data motion for variables that may be links
#	by virtue of appearing in 'nsupvar', 'upvar' or 'variable'
#	opcodes, or that may be read or written by 'invoke'
#
# Results:
#	None.
#
# Side effects:
#	Adds the necessary instructions to keep the callframe in step
#	with linked variables and with variables that may be used or
#	set in invoked commands.
#
# This pass runs before SSA, so that it doesn't need to worry about
# variable renaming. It inserts a great many redundant data motions.
# 'cleanupCallFrameMotion' will take out some of them (at least any
# 'moveFromCallFrame' whose result is unused), but proper optmization
# will depend on global alias analysis, which we don't yet have.

oo::define quadcode::transformer method callFrameMotion {} {

    my debug-callframe {
	puts "Before callframeMotion:"
	my dump-bb
	puts "Links: $links"
    }

    set catches {};		# Dictionary enumerating the places where
    ;				# errorInfo and errorCode must be spoilt

    # Walk through the basic blocks and insert any needed instructions
    # before and after the blocks

    set b -1
    foreach bb $bbcontent {
	incr b
	set newbb {}
	set pc -1
	foreach q $bb {
	    incr pc
	    my callFrameMovesBefore $b $pc newbb $q
	    lappend newbb $q
	    my callFrameMovesAfter $b $pc newbb $q
	    if {[lindex $q 0] eq "jumpMaybe"} {
		dict set catches [lindex $q 1 1] {}
		my debug-callframe {
		    puts "   [lindex $q 1] appears to be a catch block"
		}
	    }
	}
	lset bbcontent $b $newbb
    }

    # Insert instructions to spoil ::errorCode and ::errorInfo after each
    # catch.

    my debug-callframe {
	puts "Clean up catch blocks:"
    }
    dict for {b -} $catches {
	set newbb [list {startCatch {temp @callframe} {temp @callframe}}]
	my debug-callframe {
	    puts "$b:0: [lindex $newbb 0]"
	}
	dict for {var -} $links {
	    set vname [lindex $var 1]
	    set newq [list moveFromCallFrame \
			  $var {temp @callframe} \
			  [list literal $vname]]
	    my debug-callframe {
		puts "$b:[llength $newbb]: $newq"
	    }
	    lappend newbb $newq
	}
	set bb [lindex $bbcontent $b]
	lset bbcontent $b {}
	set bb [linsert $bb[set bb {}] 0 {*}$newbb]
	lset bbcontent $b $bb
    }

    my debug-callframe {
	puts "After callframeMotion:"
	my dump-bb
    }
}

# quadcode::transformer method callFrameMovesBefore --
#
#	Inserts any data motion to and from the callframe required before
#	a given quadcode instruction.
#
# Parameters:
#	b - Basic block number
#	pc - Program counter within the block
#	newbbv - Name of a variable in caller's scope accumulating the new
#	         instruction list for the block
#	q - Instruction being analyzed.
#
# Results:
#	None.
#
# Side effects:
#	The code that is needed before $q is inserted.
#
# If an instruction is an 'invoke', then 'moveToCallFrame' is needed
# before it, with all purely local variables (those that do not appear
# in 'nsupvar', 'upvar', 'variable') listed.
#
# 'load' can be treated the same way as 'invoke'. In the worst
# case, we do not know what variables they read and write, and simply have
# to deal with whatever they do to the callframe. Once we've done copy
# propagation, we can deal with the common case where 'loadStk' and
# 'storeStk' are actually reading and writing namespace-qualified
# variables.
#
# Even though 'store' does not read variables, but only writes them, it
# still needs all the 'moveToCallFrame' operations as well. The reason
# is that if it is discovered that 'store' is storing to a predictable
# place, 'moveFromCallFrame' instructions need to be eliminated.
# In that case, we need the corresponding 'moveToCallFrame' operations
# so as to look up the reaching definition of the variable.
#
# The 'cleanupCallFrameMotion' pass will optimize away the variables
# that the 'invoke' or 'load' does not read, or that are not aliased
# to the variable that the 'store' might alter.  It can also remove
# data motion involving (some of) the variables that do not need to be
# moved to the callframe because they are already there. This
# optimization may have the effect of killing 'moveFromCallFrame'
# instructions, which will be removed by the cleanup optimizations.

oo::define quadcode::transformer method callFrameMovesBefore {b pc newbbv q} {
    if {[lindex $q 0] in {
	"directAppend" "directArrayAppend" "directArrayExists" "directArrayGet"
	"directArrayLappend" "directArrayLappendList" "directArraySet"
	"directArrayUnset" "directExists" "directGet" "directLappend"
	"directLappendList" "directSet" "directUnset" "invoke" "invokeExpanded"
    }} {

	# All variables are forced into the callframe before 'invoke',
	# 'load' and 'store'. Variables that cannot be accessed are
	# optimized away later.

	upvar 1 $newbbv newbb
	set newq {moveToCallFrame {temp @callframe} {temp @callframe}}
	foreach v $vars {
	    lappend newq [list literal [lindex $v 1]] $v
	    # TODO - Store-store optimization is needed, to detect that
	    #	     $v is already in the callframe
	}
	my debug-callframe {
	    puts "    $newq"
	    puts "inserted before"
	    puts "$b:$pc: $q"
	}
	lappend newbb $newq
    }
}

# quadcode::transformer method callFrameMovesAfter --
#
#	Inserts any data motion to and from the callframe required after
#	a given quadcode instruction.
#
# Parameters:
#	b - Basic block number
#	pc - Program counter within the block
#	newbbv - Name of a variable in caller's scope accumulating the new
#	         instruction list for the block
#	q - Instruction being analyzed.
#
# Results:
#	None.
#
# Side effects:
#	The code that is needed before $q is inserted.
#
# For an 'invoke', we need to insert moves from the callframe for all
# variables, both links and strictly local variables. (Links are included
# because we don't yet know what variables the invoked command may have
# written. and if any of them potentially have aliases, we need to move
# the aliases as well as the linked variables.)
#
# 'load' requires no postaction, since it cannot alter variables.
# 'store' may be treated similarly to 'invoke'.  We can optimize later
# the common case where the name of the variable being loaded or
# stored is constant, once we've done copy propagation and know what
# the name is.
#
# For 'nsupvar', 'upvar' and 'variable', we need to insert a single
# move from the callframe to retrieve the initial value of the variable
# after creating the link.
#
# An instruction that assigns to a variable that may be a link must move
# the result to the callframe, and then move all linked variables from the
# callframe. (Alias analysis may be able to down-select what is moved here.)
#
# Many of these moves will be dead, and we depend on cleanup optimizations
# to get rid of them.

oo::define quadcode::transformer method callFrameMovesAfter {b pc newbbv q} {

    upvar 1 $newbbv newbb

    switch -exact -- [lindex $q 0] {

	"invoke" - "invokeExpanded" - "nsupvar" - "upvar" - "variable" {

	    # 'invoke', 'nsupvar', 'upvar', 'variable' are followed by
	    # 'extractCallFrame' and will be dealt with when the
	    # 'extractCallFrame' is encountered.

	}

	"extractCallFrame" {

	    # Find the instruction that altered the callframe

	    set sourceCF [lindex $q 2]

	    set pc2 $pc
	    while {$pc2 > 0} {
		incr pc2 -1
		set q2 [lindex $bbcontent $b $pc2]
		if {[lindex $q2 1] eq $sourceCF} break
	    }
	    if {$pc2 < 0} {
		error "cannot find source of callframe in $b:$pc: $q"
	    }

	    switch -exact [lindex $q2 0] {

		"invoke" - "invokeExpanded" {

		    # After 'invoke' or 'store', all variables are
		    # retrieved from the callframe. Variables that are
		    # not changed (either because an invoked proc
		    # doesn't reference them, or because they cannot
		    # alias the target of the 'store') are removed
		    # later.

		    my debug-callframe {
			puts "insert after"
			puts "$b:$pc: $q"
			puts "   (origin: $b:$pc2: $q2)"
		    }
		    foreach v $vars {
			set newq [list moveFromCallFrame $v [lindex $q 1] \
				      [list literal [lindex $v 1]]]
			my debug-callframe {
			    puts "    $newq"
			}
			lappend newbb $newq
		    }
		}

		"nsupvar" - "upvar" - "variable" {

		    # After creating a new alias as a local variable, the
		    # value of the variable has to be retrieved from the
		    # callframe.
		    upvar 1 $newbbv newbb
		    my debug-callframe {
			puts "insert after"
			puts "$b:$pc: $q"
			puts "   (origin: $b:$pc2: $q2)"
		    }
		    set litname [lindex $q2 3]
		    set name [lindex $litname 1]
		    set newq [list moveFromCallFrame \
				  [list var $name] [lindex $q 1] $litname]
		    my debug-callframe {
			puts "    $newq"
		    }
		    lappend newbb $newq
		}
	    }
	}

	"dictAppend" - "dictGet" - "dictIncr" - "dictIterStart" -
	"dictLappend" - "dictSet" - "dictSize" - "dictUnset" -
	"dictSetOrUnset" -
	"div" - "expon" - "foreachStart" -
	"initException" -
	"listAppend" - "listConcat" -
	"listIn" - "listIndex" - "listLength" - "listRange" - "listSet" -
	"mod" - "not" - "originCmd" - "regexp" -
	"strindex" - "strrange" - "strreplace" {
	    # These operations all return FAIL, and a subsequent
	    # 'extractMaybe' will be needed. The intermediate copy
	    # of the variable will not be moved to the frame. We wait
	    # for the 'extractMaybe' to move the actual value.
	}

	default {

	    # On any assignment, we move the result to the callframe,
	    # then move anything that the result might alias back from
	    # the callframe. We put a 'no op' in between so that code that
	    # tracks the callframe content can find the correct values.

	    # On a direct assignment, we also need to recover anything
	    # that might alias the direct variable.

	    set tgt [lindex $q 1]
	    set needMovesFrom 0
	    if {[lindex $tgt 0] eq "var"
		    && [dict exists $links $tgt]} {
		upvar 1 $newbbv newbb
		my debug-callframe {
		    puts "insert after"
		    puts "$b:$pc: $q"
		}
		set vname [lindex $tgt 1]
		set newq [list moveToCallFrame \
			      {temp @callframe} {temp @callframe} \
			      [list literal $vname] $tgt]
		lappend newbb $newq
		my debug-callframe {
		    puts "    $newq"
		}
		set needMovesFrom 1
	    }
	    if {[lindex $q 0] in {
		"directAppend" "directArrayAppend" "directArrayLappend"
		"directArrayLappendList" "directArraySet" "directArrayUnset"
		"directLappend" "directLappendList" "directSet" "directUnset"
	    }} {
		unset -nocomplain vname
		set tgt Nothing
		set needMovesFrom 1
	    }

	    if {$needMovesFrom} {
		if {[info exists vname]} {
		    set nopArg [list literal $vname]
		} else {
		    set nopArg Nothing
		}
		set newq2 [list callFrameNop \
			       {temp @callframe} {temp @callframe} $nopArg]
		my debug-callframe {
		    puts "    $newq2"
		}
		lappend newbb $newq2
		dict for {var -} $links {
		    if {$tgt ne $var} {
			set vname [lindex $var 1]
			set newq [list moveFromCallFrame \
				      $var {temp @callframe} \
				      [list literal $vname]]
			my debug-callframe {
			    puts "    $newq"
			}
			lappend newbb $newq
		    }
		}
	    }
	}
    }
}

# quadcode::transformer method cleanupMoveFromCallFrame --
#
#	Removes and replaces 'moveFromCallFrame' where it is known that
#	a target procedure does not write a callframe variable
#
# Results:

#	    renameTemps

	foreach pass {
	    bbpartition
	    constJumpPeephole
	    sortbb
	    loopinv
	    callFrameMotion
	    ssa
	    ud_du_chain
	    copyprop
	    fqcmd
	    varargs
	    deadbb
	    bbidom

    my debug-translate {
	puts "Translate bytecode: $originProc"
    }

    # Construct a header that sets parameters and provides a fake point
    # to which live-on-entry variables can be attached.





    set vlist [lmap x [dict get $bytecode variables] {lindex $x 1}]

    my quads entry {temp @callframe} [list literal $vlist]
    my quads @debug-context {} [list literal [list proc $originProc]]
    if {[dict exists $bytecode sourcefile]} {
	my quads @debug-file {} [list literal [dict get $bytecode sourcefile]]
    }
    if {[dict exists $bytecode initiallinenumber]} {
	my quads @debug-line {} \
	    [list literal [list [dict get $bytecode initiallinenumber] 0]]
    }
    if {[dict exists $bytecode script]} {
	my quads @debug-script {} [list literal [dict get $bytecode script]]
    }

    # Also set the variable list in this transformer for later.

    set vars [lmap v $vlist {list var $v}]


    set idx 0
    foreach v [dict get $bytecode variables] {
	if {{arg} in [lindex $v 0]} {
	    my quads param [list var [lindex $v 1]] [list arg $idx]
	}
	incr idx
    }












    # Iterate the instruction list
    dict for {pc insn} [dict get $bytecode instructions] {
	if {![dict exists $bytecode stackState $pc]} {
	    my debug-translate {
		puts "$pc: (unreachable): $insn"
	    }

		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		set auxNum [string range [lindex $insn 2] 1 end]
		set aux [lindex [dict get $bytecode auxiliary] $auxNum]
		set mid [list temp opnd0]
		set val [list temp [incr depth -1]]
		set idx 0

		foreach v [dict get $aux variables] {
		    set r [my index-to-var $v]
		    my generate-scalar-check $pc $r {TCL WRITE VARNAME} \
			"can't set \"%s\": variable is array"
		    my error-quads $pc listIndex $mid $val [list literal $idx]
		    my error-quads $pc dictGetOrNexist $r $var $mid

		    incr idx
		}

	    }
	    dictUpdateEnd {
		set var [my index-to-var [lindex $insn 1]]
		set auxNum [string range [lindex $insn 2] 1 end]
		set aux [lindex [dict get $bytecode auxiliary] $auxNum]
		set key [list temp opnd1]
		set isary [list temp opnd2]

		    my quads copy $mid Nothing
		    my quads jump [list pc [expr {$n + 4}]]
		    my quads extractScalar $mid $r
		    # Write the value to the right key of the dict
		    my error-quads $pc dictSetOrUnset $updating $updating $key $mid
		}
		my quads copy $var $updating

	    }
	    unsetScalar {
		# TODO - This doesn't complain on unsetting a nonexistent
		#        variable, it ignores '-nocomplain'
		set var [my index-to-var [lindex $insn 2]]
		my quads unset $var

	    }
	    unsetArray {
		# TODO - This doesn't complain on unsetting a nonexistent
		#        element, it ignores '-nocomplain'
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 2]]
		my generate-array-check $pc $ary $idx {TCL LOOKUP VARNAME} \
		    "can't unset \"%s(%s)\": variable isn't array"
		my quads initArrayIfNotExists $ary $ary
		my quads arrayUnset $ary $ary $idx

	    }
	    dictDone {
		# Do nothing; general free will clean up.
	    }
	    verifyDict {
		set r [list temp [incr depth -1]]
		my error-quads $pc dictSize $r $r

		    "can't set \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal 0}
	        my quads copy $result [list literal $delta]
		my generate-arith-domain-check $pc incr $var $result
		my quads purify {temp opd0} $var
		my quads purify {temp opd1} $result
		my quads add $var {temp opd0} {temp opd1}

		my quads copy $result $var
	    }
	    incrScalar1 {
		set result [list temp $depth]
		set val [list temp [incr depth -1]]
		set var [my index-to-var [lindex $insn 1]]
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal 0}
		my generate-arith-domain-check $pc incr $var $val
		my quads purify {temp opd0} $var
		my quads purify {temp opd1} $val
		my quads add $var {temp opd0} {temp opd1}

		my quads copy $result $var
	    }
	    incrArray1Imm {
		set tmp [list temp $depth]
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 1]]
		set delta [list literal [lindex $insn 2]]
		my generate-array-check $pc $ary $idx {TCL LOOKUP VARNAME} \
		    "can't read \"%s(%s)\": variable isn't array"
		my quads initArrayIfNotExists $ary $ary
		my quads copy $tmp $delta
		set res $idx
		set inval {temp opd0}
		my quads arrayGet $inval $ary $idx
		my quads initIfNotExists $inval $inval {literal 0}
		my generate-arith-domain-check $pc incr $inval $tmp
		my quads purify {temp opd1} $inval
		my quads purify {temp opd2} $tmp
		my quads add $inval {temp opd1} {temp opd2}
		my quads arraySet $ary $ary $idx $inval

		my quads copy $res $inval
	    }
	    incrArray1 {
		set delta [list temp [incr depth -1]]
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 1]]
		my generate-array-check $pc $ary $idx {TCL LOOKUP VARNAME} \
		    "can't read \"%s(%s)\": variable isn't array"
		my quads initArrayIfNotExists $ary $ary
		set res $idx
		set inval {temp opd0}
		my quads arrayGet $inval $ary $idx
		my quads initIfNotExists $inval $inval {literal 0}
		my generate-arith-domain-check $pc incr $inval $delta
		my quads purify {temp opd1} $inval
		my quads purify {temp opd2} $delta
		my quads add $inval {temp opd1} {temp opd2}
		my quads arraySet $ary $ary $idx $inval

		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}

		}
		set r [list temp $depth]
		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my error-quads $pc dictSet $r $var $val {*}[lreverse $q]
		my quads copy $var $r

	    }
	    dictUnset {
		set idxNum [expr [lindex $insn 1]]
		set var [my index-to-var [lindex $insn 2]]
		set q {}
		for {set i 0} {$i < $idxNum} {incr i} {
		    # NOTE: Reversed
		    lappend q [list temp [incr depth -1]]
		}
		set r [list temp $depth]
		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my error-quads $pc dictUnset $r $var {*}[lreverse $q]
		my quads copy $var $r

	    }
	    dictAppend - dictLappend {
		set var [my index-to-var [lindex $insn 1]]
		set val [list temp [incr depth -1]]
		set key [list temp [incr depth -1]]
		set res [list temp $depth]
		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my error-quads $pc [lindex $insn 0] $res $var $key $val
		my quads copy $var $res

	    }
	    dictIncrImm {
		set delta [list literal [lindex $insn 1]]
		set var [my index-to-var [lindex $insn 2]]
		set key [list temp [incr depth -1]]
		set res [list temp $depth]
		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my error-quads $pc dictIncr $res $var $key $delta
		my quads copy $var $res

	    }
	    list {
		set acount [lindex $insn 1]
		set depth [expr {$depth - $acount}]
		set result [list temp $depth]
		set qd {}
		for {set i 0} {$i < $acount} {incr i} {

		    set to_pc [expr {$pc + $offset}]
		    my generate-jump $to_pc true $test
		}
	    }
	    existScalar {
		set result [list temp $depth]
		set var [my index-to-var [lindex $insn 1]]


		my quads exists $result $var
	    }
	    existArray {
		set tmp [list temp $depth]
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 1]]
		set result $idx


		my quads initArrayIfNotExists $tmp $ary
		my quads arrayElementExists $result $tmp $idx
	    }

	    loadScalar1 -
	    loadScalar4 {	# Load a variable
		set result [list temp $depth]

	    storeScalar1 -
	    storeScalar4 {	# Store a variable
		incr depth -1
		set var [my index-to-var [lindex $insn 1]]
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my quads copy $var [list temp $depth]

	    }
	    storeArray1 -
	    storeArray4 {	# Store into an array
		set val [list temp [incr depth -1]]
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 1]]
		set res $idx
		my generate-array-check $pc $ary $idx {TCL LOOKUP VARNAME} \
		    "can't set \"%s(%s)\": variable isn't array"
		my quads initArrayIfNotExists $ary $ary
		my quads arraySet $ary $ary $idx $val
		my quads copy $res $val

	    }
	    tryCvtToNumeric {	# No effect on value
	    }
	    tryCvtToBoolean {	# Push whether we're dealing with a boolean
		set val [list temp [expr {$depth - 1}]]
		set res [list temp $depth]
		set typecode [quadcode::dataType::typeUnion \

		set var [my index-to-var [lindex $insn 1]]
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		set result [list temp $depth]
		my quads strcat $var $var $val
		my quads copy $result $var

	    }
	    appendArray1 - appendArray4 {
		set val [list temp [incr depth -1]]
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 1]]
		set res [list temp $depth]
		set inval {temp opd0}
		my generate-array-check $pc $ary $idx {TCL LOOKUP VARNAME} \
		    "can't set \"%s(%s)\": variable isn't array"
		my quads initArrayIfNotExists $ary $ary
		my quads arrayGet $inval $ary $idx
		my quads initIfNotExists $inval $inval {literal {}}
		my quads strcat $inval $inval $val
		my quads arraySet $ary $ary $idx $inval
		my quads copy $res $inval

	    }
	    strcat - concatStk {
		lassign $insn op count
		set strcatvals {}
		for {set i 0} {$i < $count} {incr i} {
		    lappend strcatvals [list temp [incr depth -1]]
		}

		set res [list temp $depth]
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		# TODO: Typecheck: need list in $var
		my error-quads $pc listAppend $res $var $val
		my quads copy $var $res

	    }
	    lappendList {
		set listval [list temp [incr depth -1]]
		set var [my index-to-var [lindex $insn 1]]
		set res [list temp $depth]
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		# TODO: Typecheck: need lists in $var and $listval
		my error-quads $pc listConcat $res $var $listval
		my quads copy $var $res

	    }
	    lappendArray1 - lappendArray4 {
		set val [list temp [incr depth -1]]
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 1]]
		set res [list temp $depth]
		set inval {temp opd0}
		my generate-array-check $pc $ary $idx {TCL LOOKUP VARNAME} \
		    "can't set \"%s(%s)\": variable isn't array"
		my quads initArrayIfNotExists $var $var
		my quads arrayGet $inval $ary $idx
		my quads initIfNotExists $inval $inval {literal {}}
		my error-quads $pc listAppend $inval $inval $val
		my quads arraySet $ary $ary $idx $inval
		my quads copy $res $inval

	    }
	    lappendListArray {
		set listval [list temp [incr depth -1]]
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 1]]
		set res [list temp $depth]
		set inval {temp opd0}
		my generate-array-check $pc $ary $idx {TCL LOOKUP VARNAME} \
		    "can't set \"%s(%s)\": variable isn't array"
		my quads initArrayIfNotExists $ary $ary
		my quads arrayGet $inval $ary $idx
		my quads initIfNotExists $inval $inval {literal {}}
		# TODO: Typecheck: need lists in $inval and $listval
		my error-quads $pc listConcat $inval $inval $listval
		my quads arraySet $ary $ary $idx $inval
		my quads copy $res $inval

	    }
	    listConcat {
		set list2 [list temp [incr depth -1]]
		set list1 [list temp [incr depth -1]]
		set res [list temp $depth]
		# TODO: Typecheck: need lists in $list1 and $list2
		my error-quads $pc listConcat $res $list1 $list2
	    }
	    arrayExistsImm {
		set ary [my index-to-var [lindex $insn 1]]


		set res [list temp $depth]
		my quads arrayExists $res $ary
	    }
	    arrayMakeImm {
		set ary [my index-to-var [lindex $insn 1]]
		my generate-array-check $pc $ary {} {TCL WRITE ARRAY} \
		    "can't array set \"%s\": variable isn't array"
		my quads initArrayIfNotExists $ary $ary

	    }
	    arrayExistsStk {
		set ary [list temp [incr depth -1]]
		set res [list temp $depth]
		my error-quads $pc directIsArray $res $ary
	    }
	    arrayMakeStk {

	error "Not implemented! generate-existence-check on non-constant name"
    }
    set varname [lindex $varname 1]

    set where [llength $quads]
    set newtemp [list temp @exists]



    my quads exists $newtemp $var					;# 0
    my quads jumpTrue [list pc [expr {$where + 5}]] $newtemp		;# 1
    set msg [list literal "can't read \"$varname\": no such variable"]
    set optionsDict \
	[list literal [list -errorcode [list TCL LOOKUP VARNAME $varname]]]
    my quads initException {temp @exception} $msg $optionsDict \
	{literal 1} {literal 0}						;# 2

    ;				# Name of the variable being checked

    set ok [list pc [expr {[llength $quads] + 11}]]
    ;				# Quadcode address to jump to on success
    set fail [my exception-target $pc catch]
    ;				# Bytecode address to jump to on failure
    




    # 0




    my quads exists {temp @exists} $var
    # 1
    my quads jumpFalse $ok {temp @exists}
    # 2
    my quads arrayExists {temp @exists} $var
    # 3
    my quads jumpTrue $ok {temp @exists}
    # 4
    if {$idx ne {}} {
	my quads invoke {temp @callframe} {temp @callframe} \
	    {literal ::format} [list literal $msg] \
	    [list literal $varname] $idx
    } else {
	my quads invoke {temp @callframe} {temp @callframe} \
	    {literal ::format} [list literal $msg] \
	    [list literal $varname]
    }
    # 5
    my quads retrieveResult {temp @msg} {temp @callframe}
    # 6
    my quads extractCallFrame {temp @callframe} {temp @callframe}
    # 7
    my quads extractMaybe {temp @msg} {temp @msg}
    # 8
    my quads initException {temp @exception} {temp @msg} \
	[list literal [list -errorcode $error]] \
	{literal 1} {literal 0}
    # 9
    my quads extractFail {temp @exception} {temp @exception}
    # 10
    my generate-jump $fail
    # 11

    # The narrowing pass will insert any necessary 'extract...' instructions
}

oo::define quadcode::transformer method generate-scalar-check {pc var error msg} {
    
    set varname [lindex $var 1]
    ;				# Name of the variable being checked
    set msg [list literal [format $msg $varname]]
    ;				# Preformatted message to return on error
    
    set ok [list pc [expr {[llength $quads] + 5}]]
    ;				# Quadcode address to jump to on success
    set fail [my exception-target $pc catch]
    ;				# Bytecode address to jump to on failure
    




    # 0




    my quads arrayExists {temp @exists} $var
    # 1
    my quads jumpFalse $ok {temp @exists}
    # 2
    my quads initException {temp @exception} $msg \
	[list literal [list -errorcode $error]] \
	{literal 1} {literal 0}
    # 3
    my quads extractFail {temp @exception} {temp @exception}
    # 4
    my generate-jump $fail
    # 5

    # The narrowing pass will insert any necessary 'extract...' instructions
}

# generate-arith-domain-check --
#
#	Generates a check to make sure that a value is NUMERIC or INT

	my generate-jump $target
	# 5 - ok:
        my quads [list purifyParam $i] $val $val $functionName
	# 6
	# (next instruction)
	
    }





















}

# quads --
#
#	Generate the given quadcode.
#
# Parameters: