# Results:
    #	Returns an LLVM INT reference

    method returnCode(FAIL\040STRING) {src ecode name} {
	my dropReference(FAIL\040STRING) $src
	my packInt32 $ecode $name
    }

    # Builder:returnCode(FAIL ZEROONE) --
    #
    #	Pass the Tcl return code through to an LLVM value
    #
    # Parameters:
    #	src - The FAIL ZEROONE value that encodes the last interpreter action
    #	ecode - The INT32 value that holds the return code
    #	name (optional) - A name to give to the result value
    #
    # Results:
    #	Returns an LLVM INT reference

    method returnCode(FAIL\040ZEROONE) {src ecode name} {
	my packInt32 $ecode
    }

    # Builder:returnOptions(FAIL,INT) --
    #
    #	Get the Tcl exception dictionary. Quadcode implementation
    #	('returnOptions').
    #
    # Parameters:

    while {$changed} {
	set changed 0
	my debug-tidy {
	    set debugLine {tidy:}
	}
	foreach pass {
	    copyprop



	    cleanupNarrow
	    bbidom
	    bblevel
	    deadcond
	    deadjump
	    deadbb
	    deadvars

		    if {[llength $varGroup] == 1} {
			my quads copy $idx $res
		    } else {
			my quads mult $idx $res [list literal [llength $varGroup]]
		    }
		    foreach varIndex $varGroup {
			set var [my index-to-var $varIndex]
			my generate-move-from-callframe $var
			my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
			    "can't set \"%s\": variable is array"
			my quads listIndex $var $list $idx
			my quads extractMaybe $var $var
			my quads add $idx $idx [list literal 1]
		    }
		}

		set collector [list temp [expr {$depth - [llength $assign] - 4}]]
		set value [list temp [incr depth -1]]
		my quads listAppend $collector $collector $value
		my quads extractMaybe $collector $collector
	    }
	    dictFirst {
		set var [my index-to-var [lindex $insn 1]]
		my generate-move-from-callframe $var
		set dict [list temp [incr depth -1]]
		set value [list temp $depth]
		set key [list temp [incr depth]]
		set done [list temp [incr depth]]
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my error-quads $pc dictIterStart $var $dict
		my quads dictIterKey $key $var
		my quads dictIterValue $value $var
		my quads dictIterDone $done $var
	    }
	    dictNext {
		set var [my index-to-var [lindex $insn 1]]
		set value [list temp $depth]
		set key [list temp [incr depth]]
		set done [list temp [incr depth]]
		my generate-move-from-callframe $var
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my quads dictIterNext $var $var
		my quads dictIterKey $key $var
		my quads dictIterValue $value $var
		my quads dictIterDone $done $var
	    }
	    dictUpdateStart {
		set var [my index-to-var [lindex $insn 1]]
		my generate-move-from-callframe $var
		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
		set toUpdate {}
		foreach v [dict get $aux variables] {
		    set r [my index-to-var $v]
		    my generate-move-from-callframe $r
		    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
		    lappend toUpdate [list literal [lindex $r 1]] $r
		    incr idx
		}
		my update-in-callframe {*}$toUpdate
	    }
	    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]
		set mid [list temp opnd3]
		set updating [list temp opnd4]
		set val [list temp [incr depth -1]]
		set idx 0
		my generate-move-from-callframe $var
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't write \"%s\": variable is array"
		my quads copy $updating $var
		foreach v [dict get $aux variables] {
		    set r [my index-to-var $v]
		    my generate-move-from-callframe $r
		    my error-quads $pc listIndex $key $val [list literal $idx]
		    incr idx
		    # Convert an ARRAY into a NEXIST here; ARRAY is unreadable
		    # so treat as NEXIST...
		    my quads arrayExists $isary $r
		    set n [llength $quads]
		    my quads jumpFalse [list pc [expr {$n + 3}]] $isary

		my update-in-callframe [list literal [lindex $var 1]] Nothing
	    }
	    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-move-from-callframe $ary
		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
		my update-in-callframe [list literal [lindex $ary 1]] $ary
	    }
	    dictDone {
		# Do nothing; general free will clean up.
	    }
	    verifyDict {
		set r [list temp [incr depth -1]]
		my error-quads $pc dictSize $r $r
		# The result will be discarded
	    }
	    incrScalar1Imm {
		set result [list temp $depth]
		set var [my index-to-var [lindex $insn 1]]
		set delta [lindex $insn 2]
		my generate-move-from-callframe $var
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "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 update-in-callframe [list literal [lindex $var 1]] $var
		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-move-from-callframe $var
		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 update-in-callframe [list literal [lindex $var 1]] $var
		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-move-from-callframe $ary
		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 update-in-callframe [list literal [lindex $ary 1]] $ary
		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-move-from-callframe $ary
		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}

		set var [my index-to-var [lindex $insn 2]]
		set val [list temp [incr depth -1]]
		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-move-from-callframe $var
		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
		my update-in-callframe [list literal [lindex $var 1]] $var
	    }
	    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-move-from-callframe $var
		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
		my update-in-callframe [list literal [lindex $var 1]] $var
	    }
	    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-move-from-callframe $var
		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
		my update-in-callframe [list literal [lindex $var 1]] $var
	    }
	    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-move-from-callframe $var
		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
		my update-in-callframe [list literal [lindex $var 1]] $var
	    }

		    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 generate-move-from-callframe $var
		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 generate-move-from-callframe $ary

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

	    loadScalar1 -
	    loadScalar4 {	# Load a variable
		set result [list temp $depth]
		set var [my index-to-var [lindex $insn 1]]
		my generate-move-from-callframe $var
		my generate-existence-check $pc $var
		my quads copy $result $var
		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		#my quads copy $result $var
	    }
	    loadArray1 -
	    loadArray4 {	# Load from an array
		set idx [list temp [incr depth -1]]
		set ary [my index-to-var [lindex $insn 1]]
		my generate-move-from-callframe $ary
		my generate-existence-check $pc $ary
		my generate-array-check $pc $ary $idx {TCL LOOKUP VARNAME} \
		    "can't read \"%s(%s)\": variable isn't array"
		set res $idx
		my quads arrayGet $res $ary $idx
		set name [lindex $ary 1](...)
		# FIXME: error variable name

		# For now, startCommand does nothing
		# lappend quads startCommand
	    }
	    storeScalar1 -
	    storeScalar4 {	# Store a variable
		incr depth -1
		set var [my index-to-var [lindex $insn 1]]
		my generate-move-from-callframe $var
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my quads copy $var [list temp $depth]
		my update-in-callframe [list literal [lindex $var 1]] $var
	    }
	    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-move-from-callframe $ary
		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
		my update-in-callframe [list literal [lindex $ary 1]] $ary
	    }

		set v0 [list temp [incr depth -1]]
		set r $v0
		my error-quads $pc [lindex $insn 0] $r $v0
	    }
	    appendScalar1 - appendScalar4 {
		set val [list temp [incr depth -1]]
		set var [my index-to-var [lindex $insn 1]]
		my generate-move-from-callframe $var
		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
		my update-in-callframe [list literal [lindex $var 1]] $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-move-from-callframe $ary
		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 $op $result {*}[lreverse $strcatvals]
	    }
	    lappendScalar1 - lappendScalar4 {
		set val [list temp [incr depth -1]]
		set var [my index-to-var [lindex $insn 1]]
		set res [list temp $depth]
		my generate-move-from-callframe $var
		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
		my update-in-callframe [list literal [lindex $var 1]] $var
	    }
	    lappendList {
		set listval [list temp [incr depth -1]]
		set var [my index-to-var [lindex $insn 1]]
		set res [list temp $depth]
		my generate-move-from-callframe $var
		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
		my update-in-callframe [list literal [lindex $var 1]] $var
	    }
	    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-move-from-callframe $ary
		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
		my update-in-callframe [list literal [lindex $ary 1]] $ary
	    }
	    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-move-from-callframe $ary
		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
		my update-in-callframe [list literal [lindex $ary 1]] $ary
	    }
	    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]]

		my generate-move-from-callframe $ary
		set res [list temp $depth]
		my quads arrayExists $res $ary
	    }
	    arrayMakeImm {
		set ary [my index-to-var [lindex $insn 1]]
		my generate-move-from-callframe $ary
		my generate-array-check $pc $ary {} {TCL WRITE ARRAY} \
		    "can't array set \"%s\": variable isn't array"
		my quads initArrayIfNotExists $ary $ary
		my update-in-callframe [list literal [lindex $ary 1]] $ary
	    }
	    arrayExistsStk {
		set ary [list temp [incr depth -1]]
		set res [list temp $depth]
		my error-quads $pc directIsArray $res $cf $ary
	    }
	    arrayMakeStk {

    if {[llength $args] == 2} {
	lassign $args type var
	my quads jump[string totitle $type] $target $var
    } else {
	my quads jump $target
    }
}

# generate-move-from-callframe --
#
#	Generates a 'moveFromCallFrame' instruction for a given variable.
#
# Parameters:
#	var - Variable to load
#
# Results:
#	None.
#
# Side effects:
#	Emits the quad

oo::define quadcode::transformer method generate-move-from-callframe {var} {
    my quads moveFromCallFrame $var {temp @callframe} \
	[list literal [lindex $var 1]]
}

# generate-existence-check --
#
#	Generates a check to make sure that a variable exists, and
#	appends it to the list of quadcodes being built. Do not call from
#	anywhere but bytecode-to-quads!
#

    if {$varname eq ""} {
	set varname [lreplace $var 0 0 literal]
    }
    if {[lindex $varname 0] ne "literal"} {
	error "Not implemented! generate-existence-check on non-constant name"
    }
    set varname [lindex $varname 1]
    set newtemp [list temp @exists]
    set where [llength $quads]




    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

#	requested error if it is incorrect.

oo::define quadcode::transformer method generate-array-check {pc var idx error msg} {

    set varname [lindex $var 1]
    ;				# 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
    # next-instruction

    # 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