#	The concatenated value as an LLVM value reference.

    method concat() {vector {name ""}} {
	my ExtractVector $vector
	my call ${tcl.concatenate} [list $len $ary] $name
    }

    # Builder:dictAppend(DICT,STRING,STRING) --
    #
    #	Append a value to a key in a dictionary. Quadcode implementation

    #	('dictAppend').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The value to append as an LLVM value reference.

    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The resulting dictionary as an LLVM value reference.

    method dictAppend(DICT,STRING,STRING) {dict key value {name ""}} {
	my call ${tcl.dict.append} [list $dict $key $value] $name
    }
    method dictAppend(EMPTY,STRING,STRING) {dict key value {name ""}} {
	# TODO: Optimize case?
	my call ${tcl.dict.append} [list $dict $key $value] $name
    }

    # Builder:dictExists(DICT) --
    #
    #	Find whether a key exists in a dictionary. This version uses a vector
    #	of values for the key path. Quadcode implementation ('dictExists').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	vector -
    #		The key path as an LLVM vector value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the value exists as an LLVM ZEROONE value reference.

    method dictExists(DICT) {dict vector {name ""}} {
	my ExtractVector $vector
	my call ${tcl.dict.exists} [list $dict $len $ary] $name
    }
    method dictExists(EMPTY) {dict vector {name ""}} {
	Const 0 int1
    }

    # Builder:dictExists(DICT,STRING) --
    #
    #	Find whether a key exists in a dictionary. This version uses a single
    #	simple key. Quadcode implementation ('dictExists').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Whether the value exists as an LLVM ZEROONE value reference.

    method dictExists(DICT,STRING) {dict key {name ""}} {
	my call ${tcl.dict.exists1} [list $dict $key] $name
    }
    method dictExists(EMPTY,STRING) {dict key {name ""}} {
	Const 0 int1
    }

    # Builder:dictGet(DICT) --
    #
    #	Retrieve a value from a dictionary. This version uses a vector as a
    #	key path. NOTE: this operation can fail (e.g., a key not present or an
    #	invalid dictionary inside a valid one) so it produces a STRING FAIL.
    #	Quadcode implementation ('dictGet').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	vector -
    #		The key path as an LLVM vector 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 retrieved value as an LLVM value reference, or a FAIL.

    method dictGet(DICT) {dict vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.dict.get} [list $dict $len $ary $ec] $name
    }
    method dictGet(EMPTY) {dict vector ec {name ""}} {
	# TODO: Optimize case?
	my ExtractVector $vector
	my call ${tcl.dict.get} [list $dict $len $ary $ec] $name
    }

    # Builder:dictGet(DICT,STRING) --
    #
    #	Retrieve a value from a dictionary. This version uses a single simple
    #	key. NOTE: this operation can fail so it produces a STRING FAIL.

    #	Quadcode implementation ('dictGet').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key 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 retrieved value as an LLVM value reference, or a FAIL.

    method dictGet(DICT,STRING) {dict key ec {name ""}} {
	my call ${tcl.dict.get1} [list $dict $key $ec] $name
    }
    method dictGet(EMPTY,STRING) {dict key ec {name ""}} {
	# TODO: Optimize case?
	my call ${tcl.dict.get1} [list $dict $key $ec] $name
    }

    # Builder:dictGetOrNexist(EMPTY DICT,STRING) --
    #
    #	Retrieve a value from a dictionary, or NEXIST if the key doesn't map
    #	to a value in the dict. This version uses a single simple key.


    #	Quadcode implementation ('dictGetOrNexist').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key 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 retrieved value as an LLVM value reference, or a NEXIST.

    method dictGetOrNexist(DICT,STRING) {dict key {name ""}} {
	my call ${tcl.dict.get1.empty} [list $dict $key] $name
    }
    method dictGetOrNexist(EMPTY,STRING) {dict key {name ""}} {
	# TODO: Optimize case
	my call ${tcl.dict.get1.empty} [list $dict $key] $name
    }

    # Builder:dictIncr(EMPTY DICT,STRING,INT) --
    #
    #	Increment the value for a key in a dictionary. NOTE: this operation
    #	can fail (e.g., because it can be given an invalid dictionary) so it
    #	produces a STRING FAIL. Quadcode implementation ('dictIncr').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The amount to increment by 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 resulting dictionary as an LLVM value reference, or a FAIL.

    method dictIncr(DICT,STRING,INT) {dict key value ec {name ""}} {
	my call ${tcl.dict.incr} [list $dict $key $value $ec] $name
    }
    method dictIncr(EMPY,STRING,INT) {dict key value ec {name ""}} {
	# TODO: Optimize case
	my call ${tcl.dict.incr} [list $dict $key $value $ec] $name
    }

    # Builder:dictIterStart(DICT) --
    #
    #	Start iterating over a dictionary; other opcodes are used to retrieve
    #	what the state of the iteration is. Quadcode implementation

    #	('dictIterStart').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.

    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The iteration state as an LLVM DICTITER value reference.

    method dictIterStart(DICT) {dict {name ""}} {
	my call ${tcl.dict.iterStart} [list $dict] $name
    }
    method dictIterStart(EMPTY) {dict {name ""}} {
	# TODO: Optimize case
	my call ${tcl.dict.iterStart} [list $dict] $name
    }

    # Builder:dictIterNext --
    #
    #	Get the next step when iterating over a dictionary; other opcodes are
    #	used to retrieve what the state of the iteration is. Quadcode
    #	implementation ('dictIterNext').

    # Results:
    #	The termination flag as an LLVM ZEROONE value reference.

    method dictIterDone {iter {name ""}} {
	my call ${tcl.dict.iterDone} [list $iter] $name
    }

    # Builder:dictLappend(DICT,STRING,STRING) --
    #
    #	List-append a value to a key in a dictionary. NOTE: this operation can
    #	fail (e.g., because it can be given an invalid dictionary) so it
    #	produces a DICT FAIL. Quadcode implementation ('dictLappend').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key 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 resulting dictionary as an LLVM value reference, or a FAIL.

    method dictLappend(DICT,STRING,STRING) {dict key value ec {name ""}} {
	my call ${tcl.dict.lappend} [list $dict $key $value $ec] $name
    }
    method dictLappend(EMPTY,STRING,STRING) {dict key value ec {name ""}} {
	# TODO: Optimize case
	my call ${tcl.dict.lappend} [list $dict $key $value $ec] $name
    }

    # Builder:dictSet(DICT,STRING) --
    #
    #	Set or create a value in a dictionary. This version uses a vector as a
    #	dictionary key path.. NOTE: this operation can fail (e.g., because
    #	there is an invalid dictionary nested inside) so it produces a DICT
    #	FAIL. Quadcode implementation ('dictSet').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	value -	The value as an LLVM value reference.
    #	vector -
    #		The key path as an LLVM vector 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 dictionary value or a FAIL.

    method dictSet(DICT,STRING) {dict value vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.dict.set} [list $dict $len $ary $value $ec] $name
    }
    method dictSet(EMPTY,STRING) {dict value vector ec {name ""}} {
	# TODO: Optimize case
	my ExtractVector $vector
	my call ${tcl.dict.set} [list $dict $len $ary $value $ec] $name
    }

    # Builder:dictSet(DICT,STRING,STRING) --
    #
    #	Set or create a value in a dictionary. This version uses a single
    #	simple key. Quadcode implementation ('dictSet').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The value as an LLVM value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value.

    method dictSet(DICT,STRING,STRING) {dict key value {name ""}} {
	my call ${tcl.dict.set1} [list $dict $key $value] $name
    }
    method dictSet(EMPTY,STRING,STRING) {dict key value {name ""}} {
	# TODO: Optimize case
	my call ${tcl.dict.set1} [list $dict $key $value] $name
    }

    # Builder:dictSetOrUnset(DICT,STRING,NEXIST) --
    #
    #	Remove a value in a dictionary. This version uses a single simple key.
    #	Quadcode implementation ('dictSetOrUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The NEXIST value (actually ignored).
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value.

    method dictSetOrUnset(DICT,STRING,NEXIST) {dict key value {name ""}} {
	my call ${tcl.dict.set1.empty} [list $dict $key [my nothing STRING]] $name
    }
    method dictSetOrUnset(EMPTY,STRING,NEXIST) {dict key value {name ""}} {
	# TODO: Optimize case
	my call ${tcl.dict.set1.empty} [list $dict $key [my nothing STRING]] $name
    }

    # Builder:dictSetOrUnset(DICT,STRING,NEXIST STRING) --
    #
    #	Set, create or remove a value in a dictionary. This version uses a
    #	single simple key, and the value can be NEXIST to remove the key.
    #	Quadcode implementation ('dictSetOrUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The value as an LLVM value reference, or NEXIST.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value.

    method dictSetOrUnset(DICT,STRING,NEXIST\040STRING) {dict key value {name ""}} {
	my call ${tcl.dict.set1.empty} [list $dict $key $value] $name
    }
    method dictSetOrUnset(EMPTY,STRING,NEXIST\040STRING) {dict key value {name ""}} {
	# TODO: Optimize case
	my call ${tcl.dict.set1.empty} [list $dict $key $value] $name
    }

    # Builder:dictSetOrUnset(DICT,STRING,NEXIST STRING) --
    #
    #	Set or create a value in a dictionary. This version uses a single
    #	simple key. Quadcode implementation ('dictSetOrUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	value -	The value as an LLVM value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value.

    method dictSetOrUnset(DICT,STRING,STRING) {dict key value {name ""}} {






















	my call ${tcl.dict.set1.empty} [list $dict $key [my just $value]] $name
    }
    method dictSetOrUnset(EMPTY,STRING,STRING) {dict key value {name ""}} {


















	# TODO: Optimize case

	my call ${tcl.dict.set1.empty} [list $dict $key [my just $value]] $name
    }























    # Builder:dictSize(DICT) --
    #
    #	Get the size of a dictionary, i.e., the number of key-value pairs.
    #
    # Parameters:
    #	value -	The STRING LLVM value reference to a dict to get the size of.


    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	An INT in an LLVM value reference.

    method dictSize(DICT) {value {name ""}} {
	my call ${tcl.dict.size} [list $value] $name
    }
    method dictSize(EMPTY) {value ecvar {name ""}} {
	my packInt32 [Const 0] $name
    }

    # Builder:dictUnset(DICT) --
    #
    #	Remove a key from a dictionary. This version uses a vector as a
    #	dictionary key path. NOTE: this operation can fail (e.g., because of
    #	an invalid dictionary inside a valid one) so it produces a DICT FAIL.
    #	Quadcode implementation ('dictUnset').
    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	vector -
    #		The key path as an LLVM vector 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 dictionary value.

    method dictUnset(DICT) {dict vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.dict.unset} [list $dict $len $ary $ec] $name
    }
    method dictUnset(EMPTY) {dict vector ec {name ""}} {
	# TODO: Optimize case
	my ExtractVector $vector
	my call ${tcl.dict.unset} [list $dict $len $ary $ec] $name
    }

    # Builder:dictUnset(DICT,STRING) --
    #
    #	Remove a key from a dictionary. Quadcode implementation ('dictUnset').



    #
    # Parameters:
    #	dict -	The dictionary as an LLVM value reference.
    #	key -	The key as an LLVM value reference.
    #	ec -	Where to write the error code if an error happens. (Ignored)
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The new dictionary value.

    method dictUnset(DICT,STRING) {dict key ec {name ""}} {
	my call ${tcl.dict.unset1} [list $dict $key] $name
    }
    method dictUnset(EMPTY,STRING) {dict key ec {name ""}} {
	# TODO: Optimize case
	my call ${tcl.dict.unset1} [list $dict $key] $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

    # Results:
    #	None.

    method dropReference {value} {
	my Call tcl.dropReference $value
	return
    }

    # Builder:dropReference(DICT) --
    #
    #	Generate code to decrement the reference count of a value and delete
    #	the value if it has ceased to be used.
    #
    # Parameters:
    #	value -	The DICT LLVM value reference for the operand.
    #
    # Results:
    #	None.

    method dropReference(DICT) {value} {
	my Call tcl.dropReference $value
	return
    }

    # Builder:dropReference(LIST) --
    #
    #	Generate code to decrement the reference count of a value and delete
    #	the value if it has ceased to be used.
    #
    # Parameters:
    #	value -	The LIST LLVM value reference for the operand.
    #
    # Results:
    #	None.

    method dropReference(LIST) {value} {
	my Call tcl.dropReference $value
	return
    }

    # Builder:dropReference(STRING) --
    #
    #	Generate code to decrement the reference count of a value and delete
    #	the value if it has ceased to be used.
    #
    # Parameters:

    method instanceOf.ZEROONE_BOOLEAN(STRING) {value {name ""}} {
	my call ${tcl.isZeroOneBoolean} [list $value [Const false bool]] $name
    }
    method instanceOf.IMPURE_ZEROONE_BOOLEAN(STRING) {value {name ""}} {
	my call ${tcl.isZeroOneBoolean} [list $value [Const false bool]] $name
    }

    # Builder:instanceOf.DICT --
    #
    #	Generate code to check if the given STRING contains something that can
    #	be parsed to get a DICT.

    method instanceOf.DICT(STRING) {value {name ""}} {
	my call ${tcl.isDict} [list $value] $name
    }
    method instanceOf.IMPURE_DICT(STRING) {value {name ""}} {
	my call ${tcl.isDict} [list $value] $name
    }

    # Builder:instanceOf.LIST --
    #
    #	Generate code to check if the given STRING contains something that
    #	can be parsed to get a LIST.

    method instanceOf.LIST(STRING) {value {name ""}} {
	my call ${tcl.isList} [list $value] $name
    }
    method instanceOf.IMPURE_LIST(STRING) {value {name ""}} {
	my call ${tcl.isList} [list $value] $name
    }

    # Builder:int --
    #
    #	Generate code to create an integer "literal".
    #
    # Parameters:
    #	value -	The Tcl integer that we are converting to an LLVM INT.

	    }
	} else {
	    set len [Const 0]
	}
	my call ${tcl.list.create} [list $len [my gep $objv 0 0]] $name
    }

    # Builder:listAppend(LIST,STRING) --
    #


    #	Append an element to a list. Quadcode implementation ('listAppend').
    #
    # Parameters:
    #	list -	List value to get append to, in an LLVM STRING reference.
    #	value -	The value to append as an LLVM STRING value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM LIST reference.

    method listAppend(LIST,STRING) {list value {name ""}} {
	my call ${tcl.list.append} [list $list $value] $name
    }
    method listAppend(EMPTY,STRING) {list value {name ""}} {
	my call ${tcl.list.append} [list $list $value] $name
    }

    # Builder:listConcat(LIST,LIST) --
    #
    #	Append a list of elements to a list. Quadcode implementation
    #	('listConcat').
    #
    # Parameters:
    #	list -	List value to get append to, in an LLVM LIST reference.
    #	value -	The list of values to append, as an LLVM LIST reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The concatenated list, as an LLVM LIST reference.

    method listConcat(LIST,LIST) {list value {name ""}} {
	my call ${tcl.list.concat} [list $list $value] $name
    }
    method listConcat(LIST,EMPTY) {list value {name ""}} {
	my call ${tcl.list.concat} [list $list $value] $name
    }
    method listConcat(EMPTY,LIST) {list value {name ""}} {
	my call ${tcl.list.concat} [list $list $value] $name
    }
    method listConcat(EMPTY,EMPTY) {list value {name ""}} {
	my call ${tcl.list.concat} [list $list $value] $name
    }

    # Builder:listIn(STRING,LIST) --
    #
    #	Determine if an element is present in a list by simple linear search.
    #	Quadcode implementation ('listIn').
    #
    # Parameters:
    #	value -	The value to check for, as an LLVM STRING value reference.
    #	list -	List value to search, in an LLVM LIST value reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	If the element is present, as an LLVM ZEROOONE reference.

    method listIn(STRING,LIST) {value list {name ""}} {
	my call ${tcl.list.in} [list $value $list] $name
    }
    method listIn(STRING,EMPTY) {value list {name ""}} {
	my call ${tcl.list.in} [list $value $list] $name
    }

    # Builder:listIndex(LIST) --
    #
    #	Get an element of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid interior list) so it produces a STRING
    #	FAIL. Quadcode implementation ('listIndex').
    #
    # Parameters:
    #	value -	List value to get the length of, in an LLVM LIST reference.
    #	vector -
    #		The indices as an LLVM vector value reference.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM STRING FAIL reference.

    method listIndex(LIST) {value vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.list.index} [list $value $len $ary $ec] $name
    }
    method listIndex(EMPTY) {value vector ec {name ""}} {
	my ExtractVector $vector
	my call ${tcl.list.index} [list $value $len $ary $ec] $name
    }

    # Builder:listIndex(LIST,INT) --
    #
    #	Get an element of a list. Quadcode implementation ('listIndex').
    #
    # Parameters:
    #	value -	List value to get the length of, in an LLVM LIST reference.
    #	index -	Index value to use, in an LLVM INT reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM STRING reference.

    method listIndex(LIST,INT) {value index {name ""}} {
	my call ${tcl.list.index1} [list $value $index] $name
    }
    method listIndex(LIST,INT) {value index {name ""}} {
	my call ${tcl.list.index1} [list $value $index] $name
    }

    # Builder:listIndex(LIST,STRING) --
    #
    #	Get an element of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid index) so it produces a STRING FAIL.
    #	Quadcode implementation ('listIndex').
    #
    # Parameters:
    #	value -	List value to index into, in an LLVM LIST reference.

    #	index -	Index value to use, in an LLVM STRING reference.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The element of the list, as an LLVM STRING FAIL reference.





































































    method listIndex(LIST,STRING) {value index ec {name ""}} {
	my call ${tcl.list.indexList} [list $value $index $ec] $name
    }



















    method listIndex(EMPTY,STRING) {value index ec {name ""}} {
	my call ${tcl.list.indexList} [list $value $index $ec] $name
    }

    # Builder:listLength(LIST) --
    #


    #	Get the length of a list. Quadcode implementation ('listLength').
    #
    # Parameters:
    #	value -	List value to get the length of, in an LLVM LIST reference.



    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The length of the list, as an LLVM INT reference.

    method listLength(LIST) {value {name ""}} {
	my call ${tcl.list.length} [list $value] $name
    }
    method listLength(EMPTY) {value {name ""}} {
	my packInt32 [Const 0] $name
    }

    # Builder:listRange(LIST,INT,INT) --
    #
    #	Get a sublist of a list. Quadcode implementation ('listRange').
    #
    # Parameters:
    #	value -	List value to get a substring of, in an LLVM LIST reference.
    #	from -	Index of first element to return, in an LLVM INT reference.
    #	to -	Index of last element to return, in an LLVM INT reference.
    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference. (Ignored.)
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The sublist, as an LLVM LIST FAIL reference.

    method listRange(LIST,INT,INT) {value from to ec {name ""}} {
	my call ${tcl.list.range1} [list $value $from $to] $name
    }
    method listRange(EMPTY,INT,INT) {value from to c {name ""}} {
	my call ${tcl.list.range1} [list $value $from $to] $name
    }

    # Builder:listRange(LIST,STRING,STRING) --
    #
    #	Get a sublist of a list. NOTE: this operation can fail (e.g., because
    #	it can be given an invalid list) so it produces a STRING FAIL.
    #	Quadcode implementation ('listRange').
    #
    # Parameters:
    #	value -	List value to get a substring of, in an LLVM LIST reference.























    #	from -	Index of first element to return, in an LLVM STRING reference.
    #	to -	Index of last element to return, in an LLVM STRING reference.

    #	ec -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The sublist, as an LLVM LIST FAIL reference.

    method listRange(LIST,STRING,STRING) {value from to ec {name ""}} {
	my call ${tcl.list.range} [list $value $from $to $ec] $name
    }
    method listRange(EMPTY,STRING,STRING) {value from to ec {name ""}} {
	my call ${tcl.list.range} [list $value $from $to $ec] $name
    }

    # Builder:listSet(LIST,STRING) --
    #
    #	Update an element in a sublist of a list. NOTE: this operation can
    #	fail (e.g., because it can be given an invalid index) so it produces a
    #	LIST FAIL. Quadcode implementation ('listSet').
    #
    # Parameters:
    #	list -	List value to get a substring of, in an LLVM LIST reference.
    #	elem -	The value to write into the list, in an LLVM STRING reference.
    #	vector -
    #		The indices as an LLVM vector value reference.
    #	ecvar -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The updated list, as an LLVM LIST FAIL reference.

    method listSet(LIST,STRING) {list elem vector ecvar {name ""}} {
	my ExtractVector $vector
	my call ${tcl.list.set} [list $list $len $ary $elem $ecvar] $name
    }
    method listSet(EMPTY,STRING) {list elem vector ecvar {name ""}} {
	my ExtractVector $vector
	my call ${tcl.list.set} [list $list $len $ary $elem $ecvar] $name
    }

    # Builder:listSet(LIST,INT,STRING) --
    #
    #	Update an element of a list. NOTE: this operation can fail (e.g.,
    #	because it can be given an invalid index) so it produces a LIST FAIL.
    #	Quadcode implementation ('listSet').
    #
    # Parameters:
    #	list -	List value update, in an LLVM LIST reference.
    #	idx -	The index into the list to set, in an LLVM INT reference.
    #	elem -	The value to write into the list, in an LLVM STRING reference.
    #	ecvar -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The updated list, as an LLVM LIST FAIL reference.

    method listSet(LIST,INT,STRING) {list idx elem ecvar {name ""}} {
	my call ${tcl.list.set1} [list $list $idx $elem $ecvar] $name
    }
    method listSet(EMPTY,INT,STRING) {list idx elem ecvar {name ""}} {
	my call ${tcl.list.set1} [list $list $idx $elem $ecvar] $name
    }

    # Builder:listSet(LIST,STRING,STRING) --
    #
    #	Update an element of a list or sublist. NOTE: this operation can fail
    #	(e.g., because it can be given an invalid index) so it produces a LIST
    #	FAIL. Quadcode implementation ('listSet').
    #
    # Parameters:
    #	list -	List value update, in an LLVM LIST reference.
    #	idx -	The index into the list to set, in an LLVM STRING reference.
    #	elem -	The value to write into the list, in an LLVM STRING reference.
    #	ecvar -	Location to write the Tcl return code into, as an LLVM int*
    #		reference.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	The updated list, as an LLVM LIST FAIL reference.

    method listSet(LIST,STRING,STRING) {list idx elem ecvar {name ""}} {
	my call ${tcl.list.setList} [list $list $idx $elem $ecvar] $name
    }
    method listSet(EMPTY,STRING,STRING) {list idx elem ecvar {name ""}} {
	my call ${tcl.list.setList} [list $list $idx $elem $ecvar] $name
    }

    # Builder:lor(INT,INT) --
    #
    #	Generate code to compute the logical or of two INTs.  Quadcode
    #	implementation ('lor').

	if {[string match "* NEXIST" $type]} {
	    set type [string range $type 0 end-7]
	} elseif {[string match "NEXIST *" $type]} {
	    set type [string range $type 7 end]
	}
	my insert [my undef $type!] [Const true bool] 0 $name
    }

    # Builder:narrowToType.DICT(STRING) --
    #
    #	Generate code to parse the given STRING and extract a DICT. The
    #	STRING is already be known to contain a value of the right type (due
    #	to higher-level quadcode constraints). Quadcode implementation
    #	('narrowToType').
    #
    # Parameters:
    #	value -	The STRING LLVM value reference to parse.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A DICT LLVM value reference.

    method narrowToType.DICT(STRING) {value {name ""}} {
	return $value
    }
    method narrowToType.IMPURE_DICT(STRING) {value {name ""}} {
	return $value
    }
    method narrowToType.EMPTY_DICT(STRING) {value {name ""}} {
	return $value
    }
    method narrowToType.IMPURE_EMPTY_DICT(STRING) {value {name ""}} {
	return $value
    }

    # Builder:narrowToType.LIST(STRING) --
    #
    #	Generate code to parse the given STRING and extract a LIST. The
    #	STRING is already be known to contain a value of the right type (due
    #	to higher-level quadcode constraints). Quadcode implementation
    #	('narrowToType').
    #
    # Parameters:
    #	value -	The STRING LLVM value reference to parse.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A LIST LLVM value reference.

    method narrowToType.LIST(STRING) {value {name ""}} {
	return $value
    }
    method narrowToType.IMPURE_LIST(STRING) {value {name ""}} {
	return $value
    }
    method narrowToType.EMPTY_LIST(STRING) {value {name ""}} {
	return $value
    }
    method narrowToType.IMPURE_EMPTY_LIST(STRING) {value {name ""}} {
	return $value
    }

    # Builder:unmaybe --
    #
    #	Get the value out of a FAIL or NEXIST. NOTE: The FAIL/NEXIST must be a
    #	Just or the result will be an 'undef'; test with the 'maybe' method
    #	first!
    #

    #	Returns an LLVM IMPURE NUMERIC value

    method packImpure(NUMERIC) {value {name ""}} {
	set sval [my stringify(NUMERIC) $value]
	my addReference(STRING) $sval
	return [my impure NUMERIC $sval $value $name]
    }

    # Builder:packImpure(DICT) --
    #
    #	Convert a DICT to an IMPURE DICT
    #
    # Parameters:
    #	value -	LLVM Value to pack into the 'impure' structure
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Returns an LLVM IMPURE DICT value

    method packImpure(DICT) {value {name ""}} {
	return $value
    }

    # Builder:packImpure(EMPTY DICT) --
    #
    #	Convert an EMPTY DICT to an IMPURE EMPTY DICT
    #
    # Parameters:
    #	value -	LLVM Value to pack into the 'impure' structure
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Returns an LLVM IMPURE DICT value

    method packImpure(EMPTY\040DICT) {value {name ""}} {
	return $value
    }

    # Builder:packImpure(EMPTY LIST) --
    #
    #	Convert an EMPTY LIST to an IMPURE EMPTY LIST
    #
    # Parameters:
    #	value -	LLVM Value to pack into the 'impure' structure
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Returns an LLVM IMPURE LIST value

    method packImpure(EMPTY\040LIST) {value {name ""}} {
	return $value
    }

    # Builder:packImpure(LIST) --
    #
    #	Convert a LIST to an IMPURE LIST
    #
    # Parameters:
    #	value -	LLVM Value to pack into the 'impure' structure
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	Returns an LLVM IMPURE LIST value

    method packImpure(LIST) {value {name ""}} {
	return $value
    }

    # Builder:packImpure(ZEROONE BOOLEAN) --
    #
    #	Convert a ZEROONE BOOLEAN to an IMPURE ZEROONE BOOLEAN
    #
    # Parameters:
    #	value -	LLVM Value to pack into the 'impure' structure

	    ::quadcode::typeOfOperand \
	    ::quadcode::dataType::mightbea
	namespace eval tcl {
	    namespace eval mathfunc {
		proc literal {descriptor} {
		    string equal [lindex $descriptor 0] "literal"
		}
		proc var {descriptor} {
		    string equal [lindex $descriptor 0] "var"
		}
		proc refType {type} {
		    expr {
			[uplevel 1 [list my ReferenceType? $type]]
			&& "CALLFRAME" ni $type
		    }
		}
		proc failType {type} {
		    uplevel 1 [list my FailureType? $type]
		}
		proc operandType {operand} {
		    uplevel 1 [list my OperandType $operand]
		}
		proc consumed {var search} {
		    uplevel 1 [list my IsConsumed $var $search]
		}
		proc callframe {operand} {
		    uplevel 1 [list my IsCallFrame $operand]
		}
		proc maybetype {operand type} {
		    uplevel 1 [list my MayBeType $operand $type]
		}
		proc impure {type} {
		    expr {"IMPURE" in $type}
		}
	    }
	}
    }

    # TclCompiler:ByteCode --
    #

    #
    # Results:
    #	None.

    method PrintTypedQuads {channel qs} {
	set idx -1
	set descriptions [lmap q $qs {
	    if {[string match @debug-* [lindex $q 0]]} {
		concat "[incr idx]:" $q
	    } else {
		concat "[incr idx]:" $q ":" [linsert [lmap arg [lrange $q 1 end] {
		    try {
			if {$arg eq ""} {
			    string cat VOID
			} elseif {[string match {pc *} $arg]} {
			    string cat BLOCK
			} else {
			    my ValueTypes $arg
			}
		    } on error {} {
			string cat VOID
		    }
		}] 1 "\u21d0"]
	    }
	}]
	if {$channel eq ""} {
	    return [format "%s------>\n%s" $cmd [join $descriptions \n]]
	} else {
	    puts $channel [format "%s------>\n%s" $cmd [join $descriptions \n]]
	}
    }

	# NB: block(-1) is the function entry block. It's supposed to be
	# almost entirely optimized out.
	$block(-1) build-in $b
	$b @location 0
	set errorCode [$b alloc int "tcl.errorCode"]
	set curr_block $block(-1)
	set 0 [$b int 0]
	$b store [Const 0 int] $errorCode

	##############################################################
	#
	# Create debug info for variables in LLVM

	dict for {name typecode} $vtypes {
	    lassign $name kind formalname origin
	    set type [nameOfType $typecode]

	    # Make the debugging information for the variable provided it is a
	    # variable as perceived from the Tcl level. "Internal" temporary
	    # variables aren't nearly so interesting.

	    if {var($name)} {
		if {[lindex $quads $origin 0] eq "param"} {
		    set idx [lsearch $bytecodeVars \
			[list "scalar arg" $formalname]]
		    if {$idx < 0} {
			return -code error \
			    "unmapped formal variable name: $formalname ($name)"
		    }

			my Warn "default injection for parameter %d of '%s'; injecting '%s'" \
			    [expr {$idx + 1}] [GetValueName [$func ref]] $defaultvalue
			set var [my LoadTypedLiteral $defaultvalue $type]
		    } else {
			set var [$func param $idx $name]
		    }
		    set variables($tgt) $var
		    if {impure($type) && "LIST" ni $type && "DICT" ni $type} {
			set var [$b stringifyImpure $var]
			set type STRING
		    }
		    if {refType($type)} {
			$b printref $var "param:"
			$b addReference($type) $var
			$b assume [$b shared $var]
		    }
		}
		"moveToCallFrame" {
		    set mapping [lassign $l opcode tgt src]
		    if {callframe($src)} {
			foreach {name value} $mapping {
			    set name [lindex $name 1]
			    set var [dict get $thevarmap $name]
			    if {$value ne "Nothing"} {
				set op frame.store([my OperandType $value])
				set value [my LoadOrLiteral $value]
				$b $op $value $theframe $var $name
			    } else {
				$b frame.unset $theframe $var $name
			    }
			}
		    }
		    my StoreResult $tgt [my LoadOrLiteral $src]
		}
		"retrieveResult" {
		    lassign $l opcode tgt src
		    if {operandType($src) eq "CALLFRAME"} {
			set value [$b undef NOTHING]
		    } elseif {callframe($src)} {
			set value [$b frame.value [my LoadOrLiteral $src]]
		    } else {
			set value [my LoadOrLiteral $src]
			my Warn "retrieveResult from non-callframe"
		    }
		    my StoreResult $tgt $value
		}
		"extractCallFrame" {
		    lassign $l opcode tgt src
		    if {callframe($src)} {
			set value [my LoadOrLiteral $src]
			if {operandType($src) ne "CALLFRAME"} {
			    set name [my LocalVarName $tgt]
			    set value [$b frame.frame $value $name]
			}
		    } else {
			set value $theframe
		    }
		    my StoreResult $tgt $value

			my StoreResult $tgt \
			    [$b frame.load $theframe $var $vname $name]
		    }
		}
		"result" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $tgt]
		    append opcode ( [my OperandType $src] )
		    set src [my LoadOrLiteral $src]
		    my StoreResult $tgt [$b $opcode $src $name]
		}
		"returnOptions" {
		    lassign $l opcode tgt src ecode
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    my StoreResult $tgt [$b $opcode {*}$srcs $name]
		}
		"nsupvar" - "upvar" - "variable" {
		    set srcs [lassign $l opcode tgt src]
		    set localvar [lindex $srcs 0]
		    if {!literal($localvar)} {
			error "local variable must be literal"
		    }
		    set name [my LocalVarName $tgt]
		    set var [dict get $thevarmap [lindex $localvar 1]]
		    set op [dict get {
			nsupvar  frame.bind.nsvar
			upvar	 frame.bind.upvar
			variable frame.bind.var
		    } $opcode]
		    append op ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    set res [$b $op {*}$srcs $var $theframe $errorCode $name]
		    if {"FAIL" in operandType($tgt)} {
			my SetErrorLine $errorCode \
			    [$b maybe [$b frame.value $res]]
		    }
		    my StoreResult $tgt $res
		}
		"bitor" - "bitxor" - "bitand" - "lshift" - "rshift" -
		"add" - "sub" - "mult" - "uminus" - "uplus" - "land" - "lor" -

		}
		"originCmd" {
		    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]
		    if {"FAIL" in operandType($tgt)} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}
		"list" {
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
		    set types [split [my ValueTypes {*}$srcs] ,]
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    my StoreResult $tgt [$b list $objv $srcs $types $name]
		}
		"strindex" {
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
		    set srcs [my ConvertIndices 0 strlen 1]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in operandType($tgt)} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}
		"strrange" - "strreplace" {
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
		    set srcs [my ConvertIndices 0 strlen 1 2]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in operandType($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]
		    append opcode ( [my ValueTypes {*}$srcs] )
		    set srcs [lmap s $srcs {my LoadOrLiteral $s}]
		    if {"FAIL" in operandType($tgt)} {
			set res [$b $opcode {*}$srcs $errorCode $name]

			my SetErrorLine $errorCode [$b maybe $res]
		    } else {
			set res [$b $opcode {*}$srcs $name]
		    }
		    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}]
		    set canFail [expr {"FAIL" in operandType($tgt)}]
		    set ec [if {$canFail} {list $errorCode}]
		    if {consumed($src1, $pc + 1)} {
			$b printref [lindex $srcs 0] "[lindex $l 0 0]:A:"
			set res [$b $opcode {*}$srcs {*}$ec $name]
		    } else {
			$b printref [lindex $srcs 0] "[lindex $l 0 0]:B:"
			$b addReference([my OperandType $src1]) [lindex $srcs 0]
			set res [$b $opcode {*}$srcs {*}$ec $name]
			$b dropReference([my OperandType $src1]) [lindex $srcs 0]
		    }
		    if {$canFail} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		    my StoreResult $tgt $res
		}
		"returnCode" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $tgt]
		    append opcode ( [my OperandType $src] )
		    my StoreResult $tgt \
			[$b $opcode [my LoadOrLiteral $src] \
			     [$b load $errorCode] $name]
		}
		"initException" {
		    my IssueException $l
		}
		"setReturnCode" {
		    lassign $l opcode tgt src
		    append opcode ( [my OperandType $src] )
		    my StoreResult $tgt \
			[$b $opcode [my LoadOrLiteral $src] $errorCode]
		}
		"procLeave" {
		    set srcs [lassign $l opcode tgt]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my ValueTypes {*}$srcs] )

		    set srcs [lassign $l opcode tgt srcObj]
		    set name [my LocalVarName $tgt]
		    if {[llength $srcs] == 1} {
			# Simple case
			set srcs [list $srcObj {*}$srcs]
			append opcode ( [my ValueTypes {*}$srcs] )
			set srcs [lmap s $srcs {my LoadOrLiteral $s}]
			set res [$b $opcode {*}$srcs $name]
			my StoreResult $tgt $res
		    } else {
			# Need to construct the variadic path
			set vectortypes [lmap s $srcs {my OperandType $s}]
			set vector [$b buildVector $objv $vectortypes \
				  [lmap s $srcs {my LoadOrLiteral $s}]]
			append opcode ( [my OperandType $srcObj] )
			set srcObj [my LoadOrLiteral $srcObj]
			set res [$b $opcode $srcObj $vector $errorCode $name]
			my StoreResult $tgt $res
			$b clearVector $vector
		    }
		    if {"FAIL" in operandType($tgt)} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		}
		"dictSet" {
		    set srcs [lassign $l opcode tgt srcObj srcValue]
		    set name [my LocalVarName $tgt]
		    if {[llength $srcs] == 1} {
			# Simple case
			set srcs [list $srcObj {*}$srcs $srcValue]
			append opcode ( [my ValueTypes {*}$srcs] )
			set srcs [lmap s $srcs {my LoadOrLiteral $s}]
			set res [$b $opcode {*}$srcs $name]
			my StoreResult $tgt $res
		    } else {
			# Need to construct the variadic path
			set vectortypes [lmap s $srcs {my OperandType $s}]
			set vector [$b buildVector $objv $vectortypes \
				  [lmap s $srcs {my LoadOrLiteral $s}]]
			set srcs [list $srcObj $srcValue]
			append opcode ( [my ValueTypes {*}$srcs] )
			set srcs [lmap s $srcs {my LoadOrLiteral $s}]
			set res [$b $opcode {*}$srcs $vector $errorCode $name]
			my StoreResult $tgt $res
			$b clearVector $vector
		    }
		    if {"FAIL" in operandType($tgt)} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		}
		"listSet" {
		    set srcs [lassign $l opcode tgt srcObj srcValue]
		    set name [my LocalVarName $tgt]
		    if {[llength $srcs] == 1} {
			# Simple case
			set srcs [list $srcObj {*}$srcs $srcValue]
			append opcode ( [my ValueTypes {*}$srcs] )
			set srcs [lmap s $srcs {my LoadOrLiteral $s}]
			set res [$b $opcode {*}$srcs $errorCode $name]
			my StoreResult $tgt $res
		    } else {
			# Need to construct the variadic path
			set vectortypes [lmap s $srcs {my OperandType $s}]
			set vector [$b buildVector $objv $vectortypes \
				  [lmap s $srcs {my LoadOrLiteral $s}]]
			set srcs [list $srcObj $srcValue]
			append opcode ( [my ValueTypes {*}$srcs] )
			set srcs [lmap s $srcs {my LoadOrLiteral $s}]
			set res [$b $opcode {*}$srcs $vector $errorCode $name]
			my StoreResult $tgt $res
			$b clearVector $vector
		    }
		    if {"FAIL" in operandType($tgt)} {
			my SetErrorLine $errorCode [$b maybe $res]
		    }
		}
		"copy" - "expand" {
		    lassign $l opcode tgt src
		    set value [my LoadOrLiteral $src]
		    set type [my OperandType $tgt]
		    set name [my LocalVarName $tgt]
		    SetValueName $value $name
		    if {refType($type)} {
			$b addReference($type) $value
			$b printref $value "copy:"
		    }
		    my StoreResult $tgt $value
		}
		"maptoint" {
		    lassign $l opcode tgt src map def
		    set map [lindex $map 1]
		    set def [lindex $def 1]
		    set name [my LocalVarName $tgt]
		    append opcode ( [my OperandType $src] )
		    set src [my LoadOrLiteral $src]
		    my StoreResult $tgt [$b $opcode $src $map $def $name]
		}
		"extractExists" - "extractMaybe" {
		    my IssueExtract $l
		}
		"extractFail" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $tgt]
		    append opcode ( [my OperandType $src] )
		    set src [my LoadOrLiteral $src]
		    my StoreResult $tgt [$b $opcode $src $name]
		}
		"purify" {
		    lassign $l opcode tgt src
		    set value [my LoadOrLiteral $src]
		    set srctype [my OperandType $src]
		    if {!impure($srctype)} {
			return -code error \
			    "Trying to purify something that is not impure"
		    }
		    set name [my LocalVarName $tgt]
		    if {"LIST" ni $srctype && "DICT" ni $srctype} {
			set value [$b impure.value $value $name]
		    }
		    set type [my OperandType $tgt]
		    if {refType($type)} {
			$b addReference($type) $value
			$b printref $value "purify:"
		    }
		    my StoreResult $tgt $value
		}
		"free" {
		    lassign $l opcode tgt src
		    set type [my OperandType $src]
		    if {$src ni $consumed} {
			if {$type eq "VOID"} {
			    # VOID is trivial to free
			} elseif {refType($type)} {
			    $b printref $variables($src) "free:"
			    set vt [my OperandType $src]
			    if {"ARRAY" in $vt} {
				# TRICKY POINT: need variable name to unset an array
				set name [Const [my LocalVarName $tgt] STRING]
				$b dropReference($vt) $variables($src) $name
			    } else {
				$b dropReference($vt) $variables($src)
			    }
			}
			lappend consumed $src
		    }
		}
		"exists" {
		    lassign $l opcode tgt src

			$b br $block($tgt)
		    }
		}
		"jumpTrue" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $src]
		    set tgt [lindex $tgt 1]
		    set mth isTrue([my OperandType $src])
		    set test [$b $mth [my LoadOrLiteral $src] test_$name]
		    $b condBr $test $block($tgt) $ipath($pc)
		}
		"jumpFalse" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $src]
		    set tgt [lindex $tgt 1]
		    set mth isTrue([my OperandType $src])
		    set test [$b $mth [my LoadOrLiteral $src] test_$name]
		    $b condBr $test $ipath($pc) $block($tgt)
		}
		"jump" {
		    $b br $block([lindex $l 1 1])
		}
		"return" {
		    lassign $l opcode -> frame src
		    set val [my LoadOrLiteral $src]
		    if {callframe($src)} {
			# The CALLFRAME does not leave
			set val [$b frame.value $val]
		    }
		    set type [nameOfType $returnType]
		    if {refType($type)} {
			$b printref $val "ret:"
			if {literal($src)} {

			}
		    }
		}
		"frameArgs" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $tgt]
		    set opcode frame.args
		    append opcode ( [my OperandType $src] )
		    set val [my LoadOrLiteral $src]
		    set result [$b $opcode $val $theframe $name]
		    my StoreResult $tgt $result
		}
		"frameDepth" {
		    lassign $l opcode tgt
		    set name [my LocalVarName $tgt]

			lappend consumed $src1
		    } else {
			set result [$b unshareCopy($type) $val $name]
		    }
		    $b printref $result "cat:"
		    foreach src $srcs {
			set val [my LoadOrLiteral $src]
			$b appendString([my OperandType $src]) $val $result
		    }
		    my StoreResult $tgt $result
		}
		"concat" {
		    set srcs [lassign $l opcode tgt]
		    # Need to construct the variadic vector
		    set vectortypes [lmap s $srcs {my OperandType $s}]
		    set vector [$b buildVector $objv $vectortypes \
			    [lmap s $srcs {my LoadOrLiteral $s}]]
		    set name [my LocalVarName $tgt]
		    set result [$b concat() $vector $name]
		    my StoreResult $tgt $result
		    $b clearVector $vector
		}
		"foreachStart" {
		    set srcs [lassign $l opcode tgt assign]
		    set listtypes [lmap s $srcs {my OperandType $s}]
		    set lists [lmap s $srcs {my LoadOrLiteral $s}]
		    set result [$b foreachStart \
				    [lindex $assign 1] $lists \
				    $listtypes $errorCode]
		    if {"FAIL" in operandType($tgt)} {
			my SetErrorLine $errorCode [$b maybe $result]
		    }
		    my StoreResult $tgt $result
		}
		"unshareList" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $tgt]
		    append opcode ( [my OperandType $src] )
		    set result [$b $opcode [my LoadOrLiteral $src] $name]
		    my StoreResult $tgt $result
		}
		"foreachIter" - "foreachAdvance" - "foreachMayStep" -
		"dictIterKey" - "dictIterValue" - "dictIterDone" -
		"dictIterNext" {
		    lassign $l opcode tgt src

	set varmeta [dict get $bytecode variables]
	set argtypes {STRING}
	set arguments [list [list literal $cmd]]
	foreach vinfo $varmeta {
	    if {"arg" in [lindex $vinfo 0]} {
		set vname [list var [lindex $vinfo 1] [llength $arguments]]
		lappend arguments $vname
		lappend argtypes [my OperandType $vname]
	    }
	}

	# Patch in the extra variables discovered during quadcode analysis;
	# these are never arguments as Tcl always correctly puts those in the
	# original bytecode descriptor.
	set stdnames [lmap vinfo $varmeta {lindex $vinfo 1}]

    }

    method IssueInvokeFunction {tgt func arguments vname} {
	upvar 1 callframe callframe thecallframe thecallframe
	set BASETYPES {ZEROONE INT DOUBLE NUMERIC STRING}

	set result [$b call $func $arguments $vname]
	if {operandType($tgt) eq "FAIL"} {
	    $b store $result $errorCode
	    my SetErrorLine $errorCode
	} else {
	    set ts [lmap t $BASETYPES {Type $t?}]
	    if {[TypeOf $result] in $ts} {
		$b store [$b extract $result 0] $errorCode
	    } elseif {[Type [TypeOf $result]?] eq [Type [my OperandType $tgt]]} {
		# Managed to prove non-failure in this case...
		set result [$b ok $result]
	    }
	    if {"FAIL" in operandType($tgt)} {
		my SetErrorLine $errorCode [$b maybe $result]
	    }
	}

	if {callframe($thecallframe)} {
	    set result [$b frame.pack $callframe $result]
	}
	my StoreResult $tgt $result
    }

    method IssueInvokeCommand {tgt resolved arguments argvals vname} {
	upvar 1 callframe callframe thecallframe thecallframe

	set types [lmap s $arguments {my OperandType $s}]
	if {$resolved ne ""} {
	    # FIXME: this causes wrong "wrong # args" messages
	    set argvals [lreplace $argvals 0 0 $resolved]
	}
	set vector [$b buildVector $objv $types $argvals]
	set result [$b invoke $vector \
			[expr {callframe($thecallframe)}] $callframe \

    method IssueInvokeExpanded {callframe operation} {
	set arguments [lassign $operation opcode tgt thecallframe]
	set vname [my LocalVarName $tgt]
	set expandPositions [lmap s $arguments {
	    expr {"EXPANDED" in [my OperandType $s]}
	}]
	set argvals [lmap s $arguments {my LoadOrLiteral $s}]
	set types [lmap s $arguments {my OperandType $s}]
	set vector [$b buildVector $objv $types $argvals]
	set flags [$b buildBitArray $bitv $expandPositions]
	set result [$b invokeExpanded $vector $flags $errorCode $vname]
	my SetErrorLine $errorCode [$b maybe $result]
	if {callframe($thecallframe)} {
	    set result [$b frame.pack $callframe $result]
	}

    #
    # Results:
    #	none

    method IssueWiden {operation} {
	lassign $operation opcode tgt src
	set name [my LocalVarName $tgt]
	set srctype [my OperandType $src]
	set tgttype [lindex $opcode 2]
	if {$tgttype eq ""} {
	    set tgttype [my OperandType $tgt]
	}
	if {$srctype in {"VOID" "NOTHING" "NEXIST"}} {
	    switch -glob -- $tgttype {
		"FAIL *" {
		    set t [lrange $tgttype 1 end]
		    set value [$b fail $t "" $name]
		}
		"NEXIST *" {
		    set t [lrange $tgttype 1 end]
		    set value [$b nothing $t $name]
		}
		"STRING" - "LIST" - "DICT" - "EMPTY" {
		    set value [my LoadOrLiteral "literal {}"]
		}
		default {
		    # Should be unreachable in practice
		    my Warn "widened void to %s; result is undef" $tgttype
		    set value [$b undef $tgttype]
		}

	    return [$b frame.pack $frame $value $name]
	} elseif {"CALLFRAME" in $tgttype} {
	    error "callframe injection"
	}

	# Handle FAIL-extended types
	if {"FAIL" eq $srctype && "FAIL" in $tgttype} {
	    my Warn "widen FAIL (%s) to %s" [PrintValueToString $value] $tgttype
	    # Implementation type of pure FAIL is int32 (Tcl result code)
	    set tgttype [lrange $tgttype 1 end]
	    return [$b fail $tgttype $value]
	} elseif {"FAIL" in $srctype && "FAIL" in $tgttype} {
	    set value [$b unmaybe $value]
	    set srctype [lrange $srctype 1 end]
	    set tgttype [lrange $tgttype 1 end]

		set tuple [$b arraystring.from.array $value]
	    } else {
		set svalue [my WidenedValue $value $srctype STRING]
		set tuple [$b arraystring.from.scalar $svalue]
	    }
	    return $tuple
	}

	# Variations of LIST and DICT go straight to STRING

	if {"STRING" in $tgttype && ("LIST" in $srctype || "DICT" in $srctype)} {
	    return $value
	}

	# IMPURE to IMPURE - Copy the string value, and promote the
	# inner value

	if {impure($tgttype) && impure($srctype)} {

	    set itgttype [lrange $tgttype 1 end]
	    set isrctype [lrange $srctype 1 end]
	    set ivalue [my WidenedValue [$b impure.value $value] \
			    $isrctype $itgttype]
	    set svalue [$b impure.string $value]
	    set value [$b impure $itgttype $svalue $ivalue $name]
	} elseif {impure($srctype) && "STRING" in $tgttype} {
	    set value [$b stringifyImpure $value $name]
	} elseif {[regexp {^IMPURE (.*)$} $tgttype -> innertype]} {
	    set widened [my WidenedValue $value $srctype $innertype]
	    set value [$b packImpure($innertype) $widened $name]
	} elseif {$tgttype eq "ZEROONE BOOLEAN"} {
	    if {$srctype in {"ZEROONE" "BOOLEAN"}} {
		# do nothing - the internal reps are the same

	    if {$srctype eq "DOUBLE"} {
		set value [$b packNumericDouble $value $name]
	    } else {
		set value [$b packNumericInt $value $name]
	    }
	} elseif {$srctype eq "EMPTY" && $tgttype eq "STRING"} {
	    set value [Const "" STRING]


	}
	if {[Type $tgttype] eq [Type [TypeOf $value]?]} {
	    set value [$b ok $value]
	} elseif {[Type $tgttype] eq [Type [TypeOf $value]!]} {
	    set value [$b just $value]
	} elseif {[Type $srctype] ne [Type $tgttype]} {
	    # If the types didn't end up matching, we're in deep trouble now...
	    my Warn "unimplemented convert from '%s' to '%s'" $srctype $tgttype
	}
	return $value
    }

    # TclCompiler:IssueDictExists --
    #
    #	Generate the code for testing whether an element of a dictionary

	    return
	} elseif {[llength $srcs] == 0 && $srcDict eq "literal \uf8ff"} {
	    my StoreResult $tgt [my LoadOrLiteral "literal 0"]
	    return
	}

	# Need to construct the variadic vector
	set types [lmap s $srcs {my OperandType $s}]
	set vector [$b buildVector $objv $types \
		      [lmap s $srcs {my LoadOrLiteral $s}]]
	set name [my LocalVarName $tgt]
	append opcode ( [my OperandType $srcDict] )
	set srcDict [my LoadOrLiteral $srcDict]
	my StoreResult $tgt [$b $opcode $srcDict $vector $name]
	$b clearVector $vector
	return
    }

    # TclCompiler:IssueExtract --

    # Results:
    #	none

    method IssueException {operation} {
	upvar 1 errorCode errorCode
	set srcs [lassign $operation opcode tgt src]
	set src2 [lindex $srcs 0]
	set maintype [my OperandType $src]
	set name [my LocalVarName $tgt]
	append opcode ( [my ValueTypes {*}$srcs] )
	set value [my LoadOrLiteral $src]

	# Check if we can issue more efficient code by understanding the
	# literals provided (if everything is non-literal, we can't do much).
	if {[llength $srcs] == 3 && literal($src2)} {

    #
    # Results:
    #	A Tcl boolean value.

    method IsCallFrame {operand} {
	variable ::quadcode::dataType::CALLFRAME

	return [expr {
	    !literal($operand)
	    && ([typeOfOperand $vtypes $operand] & $CALLFRAME) != 0
	}]
    }

    # TclCompiler:MayBeBasicType --
    #
    #	Get whether a particular operand may be of a particular type.
    #
    # Parameters:
    #	operand -
    #		The operand to test the type of.
    #	type -	The name of the type (see quadcode/types.tcl)
    #
    # Results:
    #	A Tcl boolean value.

    method MayBeBasicType {operand type} {
	namespace upvar ::quadcode::dataType $type typecode
	return [expr {([typeOfOperand $vtypes $operand] & $typecode) != 0}]
    }

    # TclCompiler:ValueTypes --
    #
    #	Convert the sequence of arguments (to an opcode) into the type
    #	signature tuple to use with the name of the method in the Build class
    #	to enable automatic type widening.

	if {[info exist variables($desc)]} {
	    return $variables($desc)
	}
	if {$desc eq "Nothing"} {
	    # NEXIST special case
	    return "Nothing"
	}

	if {!literal($desc)} {
	    return -code error "unsubstitutable argument: $desc"
	}
	lassign $desc -> value
	set type [nameOfType [typeOfLiteral $value]]
	return [my LoadTypedLiteral $value $type]
    }

    # TclCompiler:LoadTypedLiteral --
    #
    #	Generate the code to create a LLVM value reference, given the

    #
    # Maintainer note:
    #	DO NOT do reference count management in this function! It makes things
    #	leak or triggers use-after-free crashes. Leave that to the main
    #	compiler engine (and the STRING allocator) as that gets it right.

    method LoadTypedLiteral {value type} {
	if {impure($type)} {
	    set sval [my LoadTypedLiteral $value STRING]
	    set itype [lrange $type 1 end]
	    if {$itype in {LIST DICT {EMPTY LIST} {EMPTY DICT}}} {
		return $sval
	    }
	    set tval [my LoadTypedLiteral $value $itype]
	    return [$b impure $itype $sval $tval]
	} elseif {$type eq "DOUBLE"} {
	    return [ConstReal [Type $type] $value]
	} elseif {$type in {"ZEROONE" "BOOLEAN" "ZEROONE BOOLEAN"}} {
	    return [Const [expr {$value}] bool]
	} elseif {$type in {"INT" "ENTIER"}} {
	    return [$b int [expr {entier($value)}]]
	} elseif {$type in {"STRING" "LIST" "DICT" "EMPTY" "EMPTY LIST" "EMPTY DICT"}} {
	    set result [Const $value STRING]
	    $b assume [$b shared $result]
	    return $result
	} else {
	    return -code error \
		"unhandled type for literal \"${value}\": \"$type\""
	}

    #	None.

    method StoreResult {desc value {opcode ""}} {

	upvar 1 phiAnnotations phiAnnotations

	# Validate that the destination is indeed a variable or temporary
	if {literal($desc)} {
	    return -code error "cannot store into $desc; it makes no sense"
	}

	# Validate that SSA form has been preserved
	if {[info exists variables($desc)]} {
	    return -code error "Duplicate definition of $desc"
	}

	# Type check the assignment
	set destType [nameOfType [dict get $vtypes $desc]]
	if {[Type $destType] ne [TypeOf $value]} {
	    my Warn "Attempt to store the value '%s' into a variable, '%s', of type '%s'" \
		[PrintValueToString $value] $desc $destType
	}

	if {var($desc)} {
	    if {[lindex $opcode 0] eq "phi"} {
		lappend phiAnnotations [lindex $desc 1] $value
	    } else {
		my AnnotateAssignment [lindex $desc 1] $value
	    }
	}

    #	Boolean, true if the type is a reference type.

    method ReferenceType? {type} {
	if {[string is entier -strict $type]} {
	    set type [nameOfType $type]
	}
	foreach piece $type {
	    if {$piece in {IMPURE DICTITER EMPTY STRING ENTIER ARRAY LIST DICT}} {
		return 1
	    }
	}
	return 0
    }

    # TclCompiler:FailureType? --

    # Parameters:
    #	qcval -	The quadcode value to extract from.
    #
    # Results:
    #	The Tcl value inside the quadcode value.

    method LiteralValue {qcval} {

	if {!literal($qcval)} {
	    return -code error "assumption that '$qcval' is literal not met"
	}
	lassign $qcval -> value
	return $value
    }
}

# Class TclInterproceduralCompiler --
#
#	This class compiles a single Tcl procedure within the overall

    variable tcl.resolveCmd tcl.originCmd

    # Variables holding implementations of Tcl's list operators
    variable tcl.list.create tcl.list.length tcl.list.append tcl.list.concat
    variable tcl.list.foreach.getStep tcl.list.foreach.mayStep
    variable tcl.list.foreach.nextStep tcl.list.foreach.start.step
    variable tcl.list.foreach.start.finish tcl.list.unshare
    variable tcl.list.range tcl.list.range1 tcl.list.in tcl.isList
    variable tcl.list.index tcl.list.index1 tcl.list.indexList
    variable tcl.list.set tcl.list.set1 tcl.list.setList tcl.list.verify

    # Variables holding implementations of Tcl's dict operators
    variable tcl.dict.get1 tcl.dict.get tcl.dict.set1 tcl.dict.set
    variable tcl.dict.exists1 tcl.dict.exists tcl.dict.unset1 tcl.dict.unset
    variable tcl.dict.iterStart tcl.dict.iterNext tcl.dict.iterDone
    variable tcl.dict.iterKey tcl.dict.iterValue tcl.dict.addIterReference
    variable tcl.dict.addIterFailReference
    variable tcl.dict.dropIterReference tcl.dict.dropIterFailReference
    variable tcl.dict.append tcl.dict.lappend tcl.dict.incr tcl.dict.size
    variable tcl.dict.get1.empty tcl.dict.set1.empty tcl.isDict
    variable tcl.maptoint

    # Variables holding implementations of Tcl's exception-handling machinery
    variable tcl.getresult tcl.getreturnopts tcl.initExceptionOptions
    variable tcl.initExceptionSimple tcl.processReturn tcl.procedure.return
    variable tcl.setErrorLine tcl.existsOrError tcl.logCommandInfo
    variable tcl.handleExceptionResult tcl.invoke.command tcl.invoke.expanded

	#
	# Increment the reference count of a Tcl_Obj reference if the
	# object is supplied

	set f [$m local "tcl.addFailReference" void<-Tcl_Obj*?]
	params value:maybeObjPtr
	build {
	    my condBr [my maybe $value] $incr $nothing
	label incr "action.required.afr"
	    set value [my unmaybe $value "objPtr"]
	    $api Tcl_IncrRefCount $value
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}

	##### tcl.dropFailReference #####
	#
	# Type signature: objPtr:Tcl_Obj*? -> void
	#
	# Decrement the reference count of a Maybe containing a Tcl_Obj
	# reference, and delete it if the reference count drops to zero.

	set f [$m local "tcl.dropFailReference" void<-Tcl_Obj*?]
	params value:maybeObjPtr
	build {
	    my condBr [my maybe $value] $decr $nothing
	label decr "action.required"
	    set value [my unmaybe $value "objPtr"]
	    $api Tcl_DecrRefCount $value
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}

	#
	# Decrement the reference count of a Maybe Maybe containing a Tcl_Obj
	# reference, and delete it if the reference count drops to zero.

	set f [$m local "tcl.dropFailNExistReference" void<-Tcl_Obj*!?]
	params value:maybeObjPtr
	build {
	    my condBr [my maybe $value] $decr $nothing
	label decr "action.required"
	    my Call tcl.dropNExistReference [my unmaybe $value]
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}

	    my ret
	label gotNull "got.null"
	    set str [$api Tcl_ObjPrintf [my constString "%d:NULL\n"] $pr]
	    $api Tcl_WriteObj $chan $str
	    $api Tcl_DecrRefCount $str
	    my ret
	}
	set f [$m local writeref? void<-int,STRING?,char* noinline]
	params pr val prefix
	build {
	    my condBr [my maybe $val] $done $print
	label print:
	    my Call writeref $pr [my unmaybe $val] $prefix
	    my ret
	label done:
	    my Call writeref $pr {} $prefix
	    my ret
	}
	set f [$m local writearef void<-int,ARRAY,char* noinline]
	params pr val prefix
	build {
	    nonnull $val
	    set chan [$api Tcl_GetStdChannel [Const [expr 1<<3]]]
	    my condBr [my nonnull $prefix] $printPrefix $printRef
	label printPrefix "print.prefix"
	    set str [$api Tcl_NewStringObj $prefix [Const -1]]

	    my assume [my eq $before $after]
	    my ret $result
	}

	##### Function tcl.isPureByteArray #####
	##### Closure Build:isByteArray #####
	#
	# Type signature: objPtr:STRING -> bool
	#
	# Test if a STRING is actually a true byte array, that it can be
	# processed as bytes and not as unicode characters.

	set f [$m local "tcl.isPureByteArray" bool<-STRING readonly]
	params objPtr
	build {
	    nonnull $objPtr
	    set baType [$api tclByteArrayType]
	    set typePtr [my dereference $objPtr 0 Tcl_Obj.typePtr]
	    my condBr [my eq $baType $typePtr] $puretest $notBA
	label puretest:

	my closure isByteArray {STRING {name ""}} {
	    my call ${tcl.isPureByteArray} [list $STRING] $name
	}

	##### Function tcl.isUnicodeString #####
	##### Closure Build:isUnicodeString #####
	#
	# Type signature: objPtr:STRING -> bool
	#
	# Test if a STRING is stored internally as a sequence of Tcl_UniChar
	# (instead of as a sequence of Unicode characters encoded as UTF-8).

	set f [$m local "tcl.isUnicodeString" bool<-STRING readonly]
	params objPtr
	build {
	    nonnull $objPtr
	    set strType [$api tclStringType]
	    set type [my dereference $objPtr 0 Tcl_Obj.typePtr]
	    my ret [my eq $type $strType]
	}
	my closure isUnicodeString {STRING {name ""}} {
	    my call ${tcl.isUnicodeString} [list $STRING] $name
	}

	##### Function tcl.impl.getBoolean #####
	##### MAPPED CALL TO METHOD: Build:GetBoolean #####
	#
	# Type signature: valueObj:STRING -> bool*bool

	set f [$m local "tcl.impl.getBoolean" struct{bool,bool}<-STRING]
	params valueObj
	build {
	    nonnull $valueObj
	    set boolVar [my alloc int32 "boolPtr"]
	    set str [$api Tcl_GetString $valueObj]
	    set code [$api Tcl_GetBooleanFromObj {} $valueObj $boolVar]
	    set res [my undef struct{bool,bool}]
	    set res [my insert $res [my eq $code [Const 0]] 0]
	    set res \
		[my insert $res [my neq [my load $boolVar "bool"] [Const 0]] 1]
	    my ret $res
	}
	my closure GetBoolean {valueObj} {
	    my call ${tcl.impl.getBoolean} [list $valueObj] "result"
	}
	unset -nocomplain valueObj
	

	##### Function tcl.impl.getDouble #####
	##### MAPPED CALL TO METHOD: Build:GetDouble #####
	#
	# Type signature: valueObj:STRING -> int * int8[]
	#
	# Gets the (pseudo-)UTF-8 version of a string. Wrapper around Tcl API
	# to ensure that scope lifetime gets better understood.

	set f [$m local "tcl.impl.getDouble" struct{bool,double}<-STRING]
	my closure GetDouble {valueObj} {
	    my call ${tcl.impl.getDouble} [list $valueObj] "result"
	}
	params valueObj
	build {
	    nonnull $valueObj
	    set dblVar [my alloc double "dblPtr"]
	    set code [$api Tcl_GetDoubleFromObj {} $valueObj $dblVar]
	    set res [my undef struct{bool,double}]
	    set res [my insert $res [my eq $code [Const 0]] 0]
	    set res [my insert $res [my load $dblVar "dbl"] 1]
	    my ret $res
	}
	unset -nocomplain valueObj

	##### Function tcl.impl.getWide #####
	##### MAPPED CALL TO METHOD: Build:GetWide #####
	#
	# Type signature: valueObj:STRING -> bool * int64
	#
	# Gets an int64 from a Tcl string. Wrapper around Tcl API to ensure
	# that scope lifetime gets better understood.

	set f [$m local "tcl.impl.getWide" struct{bool,int64}<-STRING]
	my closure GetWide {valueObj {name "result"}} {
	    my call ${tcl.impl.getWide} [list $valueObj] $name
	}
	params valueObj
	build {
	    nonnull $valueObj
	    set intVar [my alloc int64 "intPtr"]

	    set p5 [my phi [list $p2 $p4] [list $nextOuter $fixP] "p.5"]
	    my ret [my sub $numBytes1 [my cast(int) [my diff $p5 $bytes]]]
	}

	##### Function tcl.impl.isAscii #####
	# Replacement for non-exposed UniCharIsAscii
	#
	# Type signature: ch:int16 -> bool
	#
	# Part of quadcode implementation ('strclass')
	#
	# Returns whether the character 'ch' is in the ASCII range.

	set f [$m local "tcl.impl.isAscii" bool<-int16 readnone]
	params ch
	build {
	    my ret [my and [my ge $ch [Const 0 int16]] \
			[my lt $ch [Const 0x80 int16]]]
	}

	##### Function tcl.impl.isXdigit #####
	# Replacement for non-exposed UniCharIsXdigit
	#
	# Type signature: ch:int16 -> bool
	#
	# Part of quadcode implementation ('strclass')
	#
	# Returns whether the character 'ch' is a hex digit.

	set f [$m local "tcl.impl.isXdigit" bool<-int16 readnone]
	params ch

	    my ret [Const true bool]
	label not:
	    my ret [Const false bool]
	}

	##### Function tcl.strclass #####
	#
	# Type signature: objPtr:STRING * class:int32 -> bool
	#
	# Quadcode implementation ('strclass')
	#
	# Returns whether all the characters in the string 'objPtr' are in the
	# character class given by 'class' (enumeration encoded as int32).

	set f [$m local "tcl.strclass" bool<-STRING,int]
	params objPtr class
	build {
	    nonnull $objPtr
	    lassign [my GetUnicode $objPtr obj] length string
	    my condBr [my gt $length $0] $test $match
	label test:
	    set end [my getelementptr $string [list $length]]

	    my ret [Const false bool]
	}

	##### Function tcl.impl.getIndex #####
	##### Closure Build:GetIndex #####
	#
	# Type signature: interp:Interp* * objPtr:Tcl_Obj* * end:int
	#			-> bool * int
	#
	# Converts an index string into an offset into something (i.e., a
	# string or list). Returns a tuple of whether the conversion succeeded
	# (a boolean) and the index.

	set f [$m local "tcl.impl.getIndex" \
		   struct{bool,int}<-Interp*,Tcl_Obj*,int readonly]

	# Type signatures: obj:STRING -> {STRING,bool}
	#		   objdupe:{STRING,bool} -> void
	#
	# Helpers for the dictionary updating functions that reduce the amount
	# of explicit branch management in the code by factoring out common
	# patterns of reference handling.

	set f [$m local "obj.dedup" struct{STRING,bool}<-STRING]
	params obj
	build {
	    set duped [my shared $obj]
	    SetValueName $duped "duped"
	    set res [my insert [my undef struct{STRING,bool}] $duped 1]
	    my condBr $duped $duplicated $unshared
	label duplicated:
	    set dupe [$api Tcl_DuplicateObj $obj]
	    SetValueName $dupe "duplicateObj"
	    my ret [my insert $res $dupe 0]
	label unshared:
	    my ret [my insert $res $obj 0]
	}
	my closure Dedup {varName} {
	    upvar 1 $varName var
	    set token [my Call obj.dedup $var]
	    set var [my extract $token 0 [GetValueName $var]]
	    return $token
	}

	set f [$m local "obj.cleanup" void<-struct{STRING,bool}]
	params objdupe
	build {
	    my condBr [my extract $objdupe 1] $duplicated $unshared
	label duplicated:
	    my dropReference [my extract $objdupe 0]
	    my ret
	label unshared:

	    set call [my Call $func $obj $new]
	    AddCallAttribute $call 1 nocapture
	    AddCallAttribute $call 2 nocapture
	    my ret $new
	label fail:
	    my ret [my null STRING]
	}

	##### Function tcl.isList #####
	#
	# Type signature: objPtr:STRING -> bool
	#
	# Part of quadcode implementation ('isInstance')
	#
	# Wrapper around Tcl_ListObjLength that uses it to do a list-ness
	# check.

	set f [$m local "tcl.isList" bool<-STRING]
	params objPtr
	build {
	    nonnull $objPtr
	    set var [my alloc int "length"]
	    set code [$api Tcl_ListObjLength {} $objPtr $var]
	    my ret [my eq $code $0]
	}

	##### Function tcl.list.create #####
	#
	# Type signature: objc:int * objv:STRING* -> STRING
	#
	# Core of quadcode implementation ('list')
	#
	# Wrapper around Tcl_NewListObj that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.create" LIST<-int,STRING*]
	params objc objv
	build {
	    nonnull $objv
	    set val [$api Tcl_NewListObj $objc $objv]
	    my addReference(STRING) $val
	    my ret $val
	}

	##### Function tcl.list.length #####
	#
	# Type signature: list:LIST -> INT
	#
	# Core of quadcode implementation ('listLength')
	#
	# Wrapper around Tcl_ListObjLength that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.length" INT<-LIST]
	params list
	build {

	    nonnull $list
	    set var [my alloc int "length"]

	    $api Tcl_ListObjLength {} $list $var


	    my ret [my packInt32 [my load $var]]



	}

	##### Function tcl.list.verify #####
	#
	# Type signature: value:STRING * ecvar:int* -> LIST?
	#
	# Core of quadcode implementation ('verifyList')
	#
	# Wrapper around a list operation (Tcl_ListObjLength) that verifies
	# that the value it is dealing with is a list; converting it to a FAIL
	# if it is not.

	set f [$m local "tcl.list.verify" LIST?<-STRING,int*]
	params value ecvar
	build {
	    noalias $value $ecvar
	    nonnull $value $ecvar
	    set var [my alloc int "length"]
	    set interp [$api tclInterp]
	    set code [$api Tcl_ListObjLength $interp $value $var]
	    my condBr [my eq $code $0] $ok $fail
	label ok:
	    $api Tcl_IncrRefCount $value
	    my ret [my ok $value]
	label fail:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.append #####
	#
	# Type signature: list:LIST * value:STRING -> LIST
	#
	# Core of quadcode implementation ('listAppend')
	#
	# Wrapper around Tcl_ListObjLength that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.append" LIST<-LIST,STRING]
	params list value
	build {

	    nonnull $list $value
	    set interp [$api tclInterp]
	    my condBr [my shared $list] $shared $unshared
	label shared "shared.duplicate"
	    set copy [my ListDupe $interp $list "copy"]


	    $api Tcl_ListObjAppendElement {} $copy $value
	    my br $return
	label unshared:
	    $api Tcl_ListObjAppendElement {} $list $value
	    my br $return
	label return:
	    set list [my phi [list $copy $list] [list $shared $unshared] "list"]
	    $api TclInvalidateStringRep $list
	    my addReference(STRING) $list
	    my condBr [my shared $value] $exit $extraRef
	label extraRef "add.extra.reference.to.value"
	    my addReference(STRING) $value
	    my br $exit
	label exit:
	    my ret $list



	}

	##### Function tcl.list.concat #####
	#
	# Type signature: list:LIST * value:LIST -> LIST
	#
	# Core of quadcode implementation ('listConcat')




	set f [$m local "tcl.list.concat" LIST<-LIST,LIST]
	params list value
	build {

	    nonnull $list $value
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]

	    $api Tcl_ListObjLength {} $list $objc


	    set len [my load $objc "len"]
	    $api Tcl_ListObjGetElements {} $value $objc $objv


	    my condBr [my shared $list] $dupe $concat
	label dupe "duplicate"
	    set copy [my ListDupe {} $list "copy"]
	    my br $concat
	label concat:
	    set working [PHI [Type LIST] {$list $copy} {$entry $dupe} "list"]
	    set objc [my load $objc "objc"]
	    set objv [my load $objv "objv"]
	    $api Tcl_ListObjReplace {} $working $len $0 $objc $objv
	    my addReference(STRING) $working
	    my ret $working



	}

	##### Function tcl.list.index #####
	#
	# Type signature: list:LIST * idxc:int * idxv:STRING* * ecvar:int*
	#			-> STRING?
	#
	# Core of quadcode implementation ('listIndex')
	#
	# Effectively an implementation of TclLindexFlat.

	set f [$m local "tcl.list.index" STRING?<-LIST,int,STRING*,int*]
	params list idxc idxv ecvar
	build {
	    noalias $list $idxv $ecvar
	    nonnull $list $idxv $ecvar
	    set iPtr [my alloc int "&i"]
	    set listPtr [my alloc STRING "&list"]
	    set listLenPtr [my alloc int "&listLen"]

	label error:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.index1 #####
	#
	# Type signature: list:LIST * index:INT -> STRING
	#
	# Core of quadcode implementation ('listIndex')
	#
	# Basic list indexing in the case where we know that the index is an
	# integer, which avoids many of the failure modes.

	set f [$m local "tcl.list.index1" STRING<-LIST,INT]
	params list index
	build {

	    nonnull $list
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]

	    set idx [my getInt32 $index]
	    $api Tcl_ListObjGetElements {} $list $objc $objv


	    my condBr [my and [my ge $idx $0] [my lt $idx [my load $objc]]] \
		$realIndex $outOfBounds
	label realIndex "real.index"
	    set objv [my load $objv "objv"]
	    set obj [my load [my getelementptr $objv [list $idx]] "objPtr"]
	    my addReference(STRING) $obj
	    my ret $obj
	label outOfBounds "out.of.bounds"
	    set obj [$api Tcl_NewObj]
	    my addReference(STRING) $obj
	    my ret $obj



	}

	##### Function tcl.list.indexList #####
	#
	# Type signature: list:LIST * index:STRING * ecvar:int* -> STRING?
	#
	# Core of quadcode implementation ('listIndex')
	#
	# Effectively an implementation of TclLindexList.

	set f [$m local "tcl.list.indexList" STRING?<-LIST,STRING,int*]
	params list index ecvar
	build {
	    noalias $ecvar
	    nonnull $list $index $ecvar
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]
	    set interp [$api tclInterp]
	    $api Tcl_ListObjGetElements {} $list $objc $objv






	    my condBr [my neq [my dereference $index 0 Tcl_Obj.typePtr] \
			[$api tclListType]] \
		$checkIndex $slowPath
	label checkIndex:
	    set len [my load $objc]
	    my condBr [my GetIndex {} $index $len idx] \
		$immediateIndex $slowPath

		    [my gep $dupe 0 Tcl_Obj.internalRep 0] \
		    TclList*] "listRep"]
	    set result [my Call tcl.list.index \
		    $list [my dereference $listRep 0 TclList.elemCount] \
		    [my gep $listRep 0 TclList.elements] $ecvar]
	    my dropReference $dupe
	    my ret $result
	label notList:
	    # We're not a list and we know it right now
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.range #####
	#
	# Type signature: list:LIST * from:STRING * to:STRING -> LIST?
	#
	# Core of quadcode implementation ('listRangeImm')




	set f [$m local "tcl.list.range" LIST?<-LIST,STRING,STRING,int*]
	params list from to ecvar
	build {
	    noalias $ecvar
	    nonnull $list $from $to $ecvar
	    set objcVar [my alloc int]
	    set objvVar [my alloc STRING*]
	    set interp [$api tclInterp]
	    $api Tcl_ListObjLength {} $list $objcVar


	    set objc [my load $objcVar "objc"]
	    set endIndex [my sub $objc $1]
	    my condBr [my GetIndex $interp $from $endIndex from] $getTo $error
	label getTo:
	    my condBr [my GetIndex $interp $to $endIndex to] $clamp $error
	label clamp:
	    set from [my select [my lt $from ${-1}] \

	label error:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.range1 #####
	#
	# Type signature: list:LIST * from:INT * to:INT -> LIST
	#
	# Core of quadcode implementation ('listRangeImm')




	set f [$m local "tcl.list.range1" LIST<-LIST,INT,INT]
	params list from to
	build {

	    nonnull $list
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]
	    set interp [$api tclInterp]
	    set from [my getInt32 $from "from"]
	    set to [my getInt32 $to "to"]
	    $api Tcl_ListObjGetElements {} $list $objc $objv


	    set objc [my load $objc]
	    set objv [my load $objv]
	    set from [my select [my lt $from ${-1}] \
		    [my add $from [my add $1 $objc]] \
		    [my min $objc $from] \
		    "from"]
	    set from [my max ${-1} $from "from"]

	label empty:
	    set r2 [$api Tcl_NewObj]
	    my br $ok
	label ok:
	    set sources [list $sublistInplaceDone $sublistNew $empty]
	    set result [my phi [list $list $r1 $r2] $sources "result"]
	    my addReference(STRING) $result
	    my ret $result



	}

	##### Function tcl.list.set #####
	#
	# Type signature: list:LIST * idxc:int * idxv:STRING* * elem:STRING
	#			* ecvar:int* -> LIST?
	#
	# Core of quadcode implementation ('lset')
	#
	# Approximately equivalent to TclLsetFlat

	set f [$m local "tcl.list.set" LIST?<-LIST,int,STRING*,STRING,int*]
	params list idxc idxv elem ecvar
	build {
	    noalias $idxv $ecvar
	    nonnull $list $idxv $elem $ecvar
	    set subList [my alloc STRING]
	    set chain [my alloc STRING]
	    set elemc [my alloc int]

	#			-> STRING?
	#
	# Core of quadcode implementation ('lset')
	#
	# Wrapper around TclListObjSetElement that exposes it to the general
	# instruction issuing code.

	set f [$m local "tcl.list.set1" LIST?<-LIST,INT,STRING,int*]
	params list idx elem ecvar
	build {
	    noalias $ecvar
	    nonnull $list $elem $ecvar
	    set objc [my alloc int "objc"]
	    set objv [my alloc STRING* "objv"]
	    set idx [my getInt32 $idx "index"]

	    set duped [my Dedup list]
	    $api Tcl_ListObjGetElements {} $list $objc $objv


	    set objc [my load $objc]
	    my condBr [my or [my lt $idx $0] [my gt $idx $objc]] \
		$error $checkOperation
	label checkOperation "operation.check"
	    set rc [my refCount $list]
	    my condBr [my eq $idx $objc] $append $set
	label append:
	    $api Tcl_ListObjAppendElement {} $list $elem
	    my br $done
	label set:
	    set call [$api TclListObjSetElement {} $list $idx $elem]
	    my br $done
	label done:
	    my assume [my eq $rc [my refCount $list]]
	    $api TclInvalidateStringRep $list
	    my addReference(STRING) $list
	    my condBr [my shared $elem] $exit2 $exit3
	label exit3 "exit"
	    my addReference(STRING) $elem
	    my br $exit2
	label exit2 "exit"
	    my ret [my ok $list]
	label error:
	    set interp [$api tclInterp]
	    $api Tcl_SetObjResult $interp \
		[$api obj.constant "list index out of range"]
	    $api Tcl_SetObjErrorCode $interp \
		[$api obj.constant {TCL OPERATION LSET BADINDEX}]


	    my Call obj.cleanup $duped
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.list.setList #####
	#
	# Type signature: list:LIST * idxArg:STRING * elem:STRING
	#			* ecvar:int* -> LIST?
	#
	# Core of quadcode implementation ('lset')
	#
	# Approximately equivalent to TclLsetList

	set f [$m local "tcl.list.setList" LIST?<-LIST,STRING,STRING,int*]
	params list idxArg elem ecvar
	build {
	    noalias $ecvar
	    nonnull $list $idxArg $elem $ecvar
	    set ary [my alloc STRING]
	    set argc [my alloc int]
	    set argv [my alloc STRING*]

		$list [my load $argc] [my load $argv] $elem $ecvar]
	    my dropReference $copy
	    my ret $code
	}

	##### Function tcl.list.in #####
	#
	# Type signature: value:STRING * list:LIST * ecVar:int* -> bool?
	#
	# Core of quadcode implementation ('listIn')
	#
	# Determines if the value is present in the list, using simple string
	# comparison.

	set f [$m local "tcl.list.in" bool<-STRING,LIST]
	params value list
	build {

	    nonnull $value $list


	    set lenVar [my alloc int]
	    set objvVar [my alloc STRING*]
	    lassign [my GetString $value "string"] len1 bytes1
	    $api Tcl_ListObjGetElements {} $list $lenVar $objvVar


	    set objc [my load $lenVar "objc"]
	    set objv [my load $objvVar "objv"]
	    my condBr [my gt $objc $0] $loop $notFound
	label loop:
	    set i [PHI [Type int32] {$0 $iLoop} {$entry $loopNext} "i"]
	    set obj [my load [my getelementptr $objv [list $i]] "obj"]
	    lassign [my GetString $obj "element"] len2 bytes2
	    my condBr [my eq $len1 $len2] $loopCompare $loopNext
	label loopCompare:
	    my condBr [my eq [my memcmp $bytes1 $bytes2 $len1] $0] \
		$found $loopNext
	label loopNext:
	    set iLoop [set i [my add $i $1 "i"]]
	    my condBr [my lt $i $objc] $loop $notFound
	label notFound "not.found"

	    my ret [Const false bool]
	label found:


	    my ret [Const true bool]
	}

	##### Function tcl.list.unshare #####
	#
	# Type signature: list:LIST -> LIST
	#
	# Core of quadcode implementation ('unshareList')
	#
	# Approximately equivalent to TclListObjCopy

	set f [$m local "tcl.list.unshare" STRING<-STRING]
	params list

	    my addReference(STRING) $copy
	    my ret $copy
	}

	##### Function tcl.list.foreach.start.step #####
	#
	# Type signature:
	#	nsteps:int? * list:LIST * stride:int -> nsteps:int?
	#
	# Core of quadcode implementation ('foreachStart')
	#
	# Works with one pair of list and assignment pattern, making sure
	# that the list is really a list, and updating the number of iterations
	# according to the given stride.

	set f [$m local "tcl.list.foreach.start.step" \
		   int?<-int?,LIST,int]
	params steps_init list stride
	build {
	    noalias $list
	    nonnull $list
	    set objcVar [my alloc int]
	    set interp [$api tclInterp]
	    my condBr [my maybe $steps_init] $earlierError $listLength
	label earlierError:
	    my ret $steps_init
	label listLength:
	    $api Tcl_ListObjLength {} $list $objcVar


	    set steps_before [my unmaybe $steps_init]
	    set objc [my load $objcVar "objc"]
	    set count [my div [my add $objc [my sub $stride [Const 1 int]]] \
			   $stride "count"]
	    my ret [my ok [my max $steps_before $count "steps"]]








	}

	##### Function: tcl.list.foreach.start.finish #####
	#
	# Type signature: steps:int?,ecvar:int*->FAIL FOREACH
	#
	# After 'tcl.list.foreach.start.step' has run for each assignment

	params pair
	build {
	    my ret [my packInt32 [my extract $pair FOREACH.val]]
	}

	##### Function tcl.list.foreach.mayStep #####
	#
	# Type signature: pair:FOREACH -> bool
	#
	# Core of quadcode implementation ('foreachMayStep')
	#
	# Part of how lists are iterated over. This is broken up into several
	# pieces because of the number of different things assigned to. This
	# part gets whether the end of the iterations has been reached.

	set f [$m local "tcl.list.foreach.mayStep" bool<-FOREACH readnone]
	params pair
	build {
	    set val [my extract $pair FOREACH.val]
	    set max [my extract $pair FOREACH.max]
	    my ret [my lt $val $max]
	}

    #		Thunk class).
    #
    # Results:
    #	None.

    method DictionaryFunctions {api} {
	upvar 1 0 0 1 1

	##### Function tcl.isDict #####
	#
	# Type signature: objPtr:STRING -> bool
	#
	# Part of quadcode implementation ('isInstance')
	#
	# Wrapper around Tcl_DictObjSize that uses it to do a dict-ness check.

	set f [$m local "tcl.isDict" bool<-STRING]
	params objPtr
	build {
	    nonnull $objPtr
	    set var [my alloc int "length"]
	    set code [$api Tcl_DictObjSize {} $objPtr $var]
	    my ret [my eq $code $0]
	}

	##### Function tcl.dict.exists1 #####
	#
	# Type signature: dict:DICT * key:STRING -> bool
	#
	# Tests if a key is in a dictionary.

	set f [$m local "tcl.dict.exists1" bool<-DICT,STRING]
	params dict key
	build {
	    nonnull $dict $key
	    set resvar [my alloc STRING "valueVar"]
	    my store [my null STRING] $resvar
	    set result [$api Tcl_DictObjGet {} $dict $key $resvar]
	    my ret [my and [my eq $result $0] \
		    [my nonnull [my load $resvar "value"]] \
		    "exists"]
	}

	##### Function tcl.dict.exists #####
	#
	# Type signature: dict:DICT * pathlen:int * pathobjs:STRING* -> bool

	#

	# Tests if a key is present in a dictionary. Never fails.

	set f [$m local "tcl.dict.exists" bool<-DICT,int,STRING*]
	params dict keyc keyv
	build {
	    noalias $dict $keyv
	    nonnull $dict $keyv
	    set dummy [my alloc int "dummy"]
	    set resvar [my alloc STRING "valueVar"]
	    my condBr [my eq $keyc $0] $verify $exists

		    "exists"]
	label notOK:
	    my ret [Const false bool]
	}

	##### Function tcl.dict.size #####
	#
	# Type signature: dict:DICT -> INT
	#
	# Gets the size of a dictionary.


	set f [$m local "tcl.dict.size" INT<-DICT]
	params dict
	build {

	    nonnull $dict
	    set size [my alloc int "size"]

	    $api Tcl_DictObjSize {} $dict $size


	    my ret [my packInt32 [my load $size]]



	}

	##### Function tcl.dict.get1 #####
	#
	# Type signature: dict:DICT * key:STRING * ecvar:int32* -> STRING?
	#
	# Gets a value by key from a dictionary.  Can fail if the key is
	# absent.

	set f [$m local "tcl.dict.get1" STRING?<-DICT,STRING,int*]
	params dict key ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $ecvar
	    set resvar [my alloc STRING "valueVar"]
	    set interp [$api tclInterp]
	    $api Tcl_DictObjGet {} $dict $key $resvar


	    set value [my load $resvar "value"]
	    my condBr [my nonnull $value] $return $fail
	label return:
	    my addReference(STRING) $value
	    my ret [my ok $value]
	label fail:
	    set keyval [$api Tcl_GetString $key]
	    $api Tcl_SetObjResult $interp \
		[$api Tcl_ObjPrintf [my constString \
			"key \"%s\" not known in dictionary"] \
		    $keyval]
	    $api Tcl_SetErrorCode $interp \
		[my constString TCL] [my constString LOOKUP] \
		[my constString DICT] $keyval {}


	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.get #####
	#
	# Type signature: dict:DICT * pathlen:int * pathobjs:STRING*
	#			* ecvar:int32* -> STRING?
	#
	# Gets a value by key from a dictionary.  Can fail if a "dict" inside
	# the dict is not a valid dictionary.

	set f [$m local "tcl.dict.get" STRING?<-DICT,int,STRING*,int*]
	params dict keyc keyv ecvar
	build {
	    noalias $dict $keyv $ecvar
	    nonnull $dict $keyv $ecvar
	    set dummy [my alloc int "dummy"]
	    set resvar [my alloc STRING "valueVar"]
	    set interp [$api tclInterp]

	label notOK:
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.get1.empty #####
	#
	# Type signature: dict:DICT * key:STRING -> STRING!
	#
	# Gets a value by key from a dictionary. An absent key in the terminal

	# dictionary is reported as an NEXIST result.

	set f [$m local "tcl.dict.get1.empty" STRING!<-DICT,STRING]
	params dict key
	build {

	    nonnull $dict $key
	    set resvar [my alloc STRING "valueVar"]

	    $api Tcl_DictObjGet {} $dict $key $resvar


	    set value [my load $resvar "value"]
	    my condBr [my nonnull $value] $return $empty
	label return:
	    my addReference(STRING) $value
	    my ret [my just $value]
	label empty:
	    my ret [my nothing STRING]



	}

	##### Function tcl.dict.set1 #####
	#
	# Type signature: dict:DICT * key:STRING * value:STRING -> DICT

	#
	# Sets a key in a dictionary to map to a value.


	set f [$m local "tcl.dict.set1" DICT<-DICT,STRING,STRING]
	params dict key value
	build {

	    nonnull $dict $key $value

	    set dd [my Dedup dict]
	    $api Tcl_DictObjPut {} $dict $key $value


	    my addReference(STRING) $dict
	    my condBr [my shared $value] $exit2 $exit3
	label exit3 "exit"
	    my addReference(STRING) $value
	    my ret $dict
	label exit2 "exit"
	    my ret $dict




	}

	##### Function tcl.dict.set #####
	#
	# Type signature: dict:STRING * pathlen:int * pathobjs:STRING*
	#			* value:STRING * ecvar:int32* -> STRING?
	#
	# Sets a key (or rather a key path) in a dictionary to map to a value.
	# Can fail if the "dict" is not a valid dictionary.

	set f [$m local "tcl.dict.set" DICT?<-DICT,int,STRING*,STRING,int*]
	params dict pathlen pathobjs value ecvar
	build {
	    noalias $pathobjs $ecvar
	    nonnull $dict $pathobjs $value $ecvar
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjPutKeyList $interp $dict $pathlen $pathobjs $value]

	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.unset1 #####
	#
	# Type signature: dict:DICT * key:STRING -> DICT
	#
	# Removes a key from a dictionary.


	set f [$m local "tcl.dict.unset1" DICT<-DICT,STRING]
	params dict key
	build {

	    nonnull $dict $key

	    set dd [my Dedup dict]
	    $api Tcl_DictObjRemove {} $dict $key


	    my addReference(STRING) $dict
	    my ret $dict




	}

	##### Function tcl.dict.unset #####
	#
	# Type signature: dict:DICT * pathlen:int * pathobjs:STRING*
	#			* ecvar:int32* -> DICT?
	#
	# Removes a key (or rather a key path) from a dictionary. Can fail if
	# the dictionary contains a "dict" that is not a valid dictionary.

	set f [$m local "tcl.dict.unset" DICT?<-DICT,int,STRING*,int*]
	params dict pathlen pathobjs ecvar
	build {
	    noalias $dict $pathobjs $ecvar
	    nonnull $dict $pathobjs $ecvar
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    set result [$api Tcl_DictObjRemoveKeyList $interp $dict $pathlen $pathobjs]
	    my condBr [my eq $result $0] $OK $notOK
	label OK:
	    my ret [my ok $dict]
	label notOK:
	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.set1.empty #####
	#
	# Type signature: dict:DICT * key:STRING * value:STRING! -> DICT

	#
	# Sets a key in a dictionary to map to a value, or removes the mapping
	# if the value is NEXIST.


	set f [$m local "tcl.dict.set1.empty" DICT<-DICT,STRING,STRING!]

	params dict key value
	build {

	    nonnull $dict $key
	    my condBr [my exists $value] $reallySet $reallyUnset
	label reallySet "real.set"
	    set value [my unmaybe $value]
	    my ret [my Call tcl.dict.set1 $dict $key $value]
	label reallyUnset "real.unset"
	    my ret [my Call tcl.dict.unset1 $dict $key]
	}

	##### Function tcl.dict.addIterReference #####
	#
	# Type signature: iter:DICTITER -> void
	#
	# Increments the reference count inside a dictionary iteration state.

	label release:
	    my Call tcl.dict.addIterReference [my unmaybe $value]
	    my ret
	}

	##### Function tcl.dict.iterStart #####
	#
	# Type signature: dict:DICT -> DICTITER
	#
	# Starts iterating over a dictionary. The current state of the

	# iteration is stored inside the returned iteration state value.

	set f [$m local "tcl.dict.iterStart" DICTITER<-DICT]
	params dict
	build {

	    nonnull $dict
	    set done [my alloc int "done"]
	    set interp [$api tclInterp]
	    set iter [$api cknew DICTFOR]
	    set key [my gep $iter 0 DICTFOR.key]
	    SetValueName $key "keyPtr"
	    set value [my gep $iter 0 DICTFOR.value]
	    SetValueName $value "valuePtr"
	    set search [my gep $iter 0 DICTFOR.search]
	    $api Tcl_DictObjFirst $interp $dict $search $key $value $done



	    my storeInStruct $iter DICTFOR.dict $dict
	    my storeInStruct $iter DICTFOR.ref $0
	    my storeInStruct $iter DICTFOR.done [my neq [my load $done] $0]
	    my addReference(STRING) $dict
	    my Call tcl.dict.addIterReference $iter
	    my ret $iter




	}

	##### Function tcl.dict.iterNext #####
	#
	# Type signature: iter:DICTITER -> DICTITER
	#
	# Continues iterating over a dictionary. The current state of the

	    set obj [my phi [list $obj $new] [list $real $alloc] "obj"]
	    my addReference(STRING) $obj
	    my ret $obj
	}

	##### Function tcl.dict.iterDone #####
	#
	# Type signature: iter:DICTITER -> bool
	#
	# Gets whether this iteration of the dictionary has finished.

	set f [$m local "tcl.dict.iterDone" bool<-DICTITER]
	params iter
	build {
	    nonnull $iter
	    my ret [my dereference $iter 0 DICTFOR.done]
	}

	##### Function tcl.dict.append #####
	#
	# Type signature: dict:DICT * key:STRING * value:STRING -> DICT

	#
	# Appends to value in a dictionary indicated by a key.


	set f [$m local "tcl.dict.append" DICT<-DICT,STRING,STRING]
	params dict key value
	build {

	    nonnull $dict $key $value
	    set valuePtr [my alloc STRING "valuePtr"]
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    $api Tcl_DictObjGet {} $dict $key $valuePtr


	    set dictVal [my load $valuePtr "value.in.dict"]
	    my condBr [my nonnull $dictVal] $append $set
	label set:
	    $api Tcl_DictObjPut {} $dict $key $value
	    my br $done
	label append:
	    my condBr [my shared $dictVal] $dupePut $directUpdate
	label directUpdate:
	    $api Tcl_AppendObjToObj $dictVal $value
	    $api TclInvalidateStringRep $dict
	    my br $done
	label dupePut:
	    set dictVal2 [$api Tcl_DuplicateObj $dictVal]
	    $api Tcl_AppendObjToObj $dictVal2 $value
	    set c [$api Tcl_DictObjPut {} $dict $key $dictVal2]
	    AddCallAttribute $c 3 nocapture
	    my br $done
	label done:
	    my addReference(STRING) $dict
	    my ret $dict




	}

	##### Function tcl.dict.incr #####
	#
	# Type signature: dict:DICT * key:STRING * value:INT
	#			* ecvar:int32* -> DICT?
	#
	# Adds an integer to an integer in a dictionary indicated by a key.

	# Can fail if the value pointed to is not a valid integer.

	set f [$m local "tcl.dict.incr" DICT?<-DICT,STRING,INT,int*]
	params dict key value ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $ecvar
	    set valuePtr [my alloc STRING "valuePtr"]
	    set intVar [my alloc int64 "intPtr"]
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    $api Tcl_DictObjGet {} $dict $key $valuePtr


	    set dictVal [my load $valuePtr "value.in.dict"]
	    my condBr [my nonnull $dictVal] $add $set
	label set:
	    set strVal [my stringify(INT) $value "value"]
	    my br $done
	label add:
	    # TODO: Revisit once we support bignums

	    my Call obj.cleanup $dd
	    my store $1 $ecvar
	    my ret [my fail STRING]
	}

	##### Function tcl.dict.lappend #####
	#
	# Type signature: dict:DICT * key:STRING * value:STRING
	#			* ecvar:int32* -> DICT?
	#
	# Appends to list in a dictionary indicated by a key.  Can fail if the
	# value pointed to is not a valid list.


	set f [$m local "tcl.dict.lappend" DICT?<-DICT,STRING,STRING,int*]
	params dict key value ecvar
	build {
	    noalias $ecvar
	    nonnull $dict $key $value $ecvar
	    set valuePtr [my alloc STRING "valuePtr"]
	    set interp [$api tclInterp]
	    set dd [my Dedup dict]
	    $api Tcl_DictObjGet {} $dict $key $valuePtr


	    set dictVal [my load $valuePtr "value.in.dict"]
	    my condBr [my nonnull $dictVal] $append $set
	label set:
	    my store $value $valuePtr
	    set newlist [$api Tcl_NewListObj $1 $valuePtr]
	    $api Tcl_DictObjPut {} $dict $key $newlist
	    my br $done

    #	None.

    method StringComparisonFunctions {api} {
	upvar 1 sizeof sizeof 0 0 1 1

	##### Function tcl.streq #####
	#
	# Type signature: value1Ptr:STRING * value2Ptr:STRING -> bool
	#
	# Quadcode implementation ('streq')
	#
	# Returns whether the two string arguments are equal.

	set f [$m local "tcl.streq" bool<-STRING,STRING]
	params v1:value1Ptr v2:value2Ptr
	build {
	    nonnull $v1 $v2
	    my condBr [my eq $v1 $v2] $identical $nexttest
	label nexttest:
	    my condBr [my and [my isByteArray $v1] [my isByteArray $v2]] \
		$cmpBA $nexttest2

	    set diff [my phi [list $diffBA $diffUni $diffUtf] $sources]
	    my ret [my select [my eq $match $0] $diff $match]
	}

	##### Function tcl.strmatch #####
	#
	# Type signature: nocase:INT * pattern:STRING * string:STRING
	#			-> bool
	#
	# Quadcode implementation ('strmatch')
	#
	# Returns whether the glob pattern in 'pattern' matches 'string'. If
	# 'nocase' is non-zero, performs the match case-insensitively.

	set f [$m local "tcl.strmatch" bool<-INT,STRING,STRING]
	params nocaseInt:nocase patternObj:pattern stringObj:string
	build {
	    nonnull $patternObj $stringObj
	    set nocase [my getInt32 $nocaseInt]
	    my condBr [my isUnicodeString $patternObj] $test2 $ordinary
	label test2:
	    my condBr [my isUnicodeString $stringObj] $unicode $ordinary

		    $nocase]
	    my ret [my neq $match $0]
	}

	##### Function tcl.regexp #####
	#
	# Type signature: flags:INT * regexp:STRING * string:STRING
	#			* errVar:int* -> bool?
	#
	# Quadcode implementation ('regexp')
	#
	# Returns whether the regular expression in 'regexp' matches 'string'
	# as a WRAPPED BOOLEAN. The 'flags' control things like whether we are
	# matching case-insensitively. If the code fails (generally because of
	# a bad regular expression) then the result is a Nothing. The variable
	# pointed to by 'errVar' is set to the relevant Tcl result code.

	set f [$m local "tcl.regexp" bool?<-INT,STRING,STRING,int*]
	params flags patternObj:regexp stringObj:string errVar:errorCode
	build {
	    noalias $errVar
	    nonnull $patternObj $stringObj $errVar
	    set interp [$api tclInterp]
	    set RE [$api Tcl_GetRegExpFromObj $interp $patternObj \
		    [my getInt32 $flags]]
	    my condBr [my nonnull $RE] $exec $err
	label exec "re.exec"
	    set match [$api Tcl_RegExpExecObj $interp $RE $stringObj $0 $0 $0]
	    my condBr [my ge $match $0] $done $err
	label done "re.done"
	    my store $0 $errVar
	    my ret [my ok [my gt $match $0]]
	label err "re.error"
	    my store $1 $errVar
	    my ret [my fail bool]
	}

    }

    # Builder:@apiFunctions --
    #
    #	Generate the quadcode operator implementations that require access to

	# Type signature: returnCode:INT -> STRING
	#
	# Quadcode implementation ('returnOptions')
	#
	# Returns the return options dictionary. Note that this requires the
	# current Tcl result code in order to work correctly.

	set f [$module local "tcl.getreturnopts" DICT<-INT]
	params value:returnCode
	build {
	    set code [my int.32 $value "code"]
	    set opts [$api Tcl_GetReturnOptions [$api tclInterp] $code]
	    SetValueName $opts "optionsObj"
	    my addReference(STRING) $opts
	    my ret $opts
	}

	##### Function tcl.initExceptionOptions #####
	#
	# Type signature: objPtr:STRING * dictPtr:DICT -> int
	#
	# Initialises the return options from what we know about an exception.

	set f [$module local "tcl.initExceptionOptions" int<-STRING,DICT]
	params result:objPtr opts:dictPtr
	build {
	    nonnull $result $opts
	    set interp [$api tclInterp]
	    set code [$api Tcl_SetReturnOptions $interp $opts]
	    my switch $code $other 0 $ok 1 $error
	label ok:

	    my store [my or [my load $field] [Const 0x800]] $field
	    my ret
	}

	##### Function tcl.processReturn #####
	#
	# Type signature: result:STRING * code:int * level:int
	#			* returnOpts:DICT -> int
	#
	# Initialises the return options from what we know about an exception.
	# Analogous to TclProcessReturn, which isn't exposed.
	#
	# Note that returnOpts may be NULL; that's equivalent to an empty
	# options dictionary, but is special-cased so it is handled more
	# efficiently by the optimizer.

	set f [$module local "tcl.processReturn" int<-STRING,int,int,DICT]
	params result code level returnOpts
	build {
	    nonnull $result
	    set valuePtr [my alloc STRING "valuePtr"]
	    set infoLen [my alloc int "infoLen"]
	    set objcPtr [my alloc int]
	    set objvPtr [my alloc STRING*]

	    my br $done
	label done:
	    my ret
	}

	##### Function tcl.booleanTest #####
	#
	# Type signature: objPtr:Tcl_Obj* -> bool
	#
	# Part of quadcode implementation ('isBoolean')
	#
	# Returns whether the string 'objPtr' is a Boolean bareword

	set f [$m local "tcl.booleanTest" bool<-Tcl_Obj*]
	params objPtr
	build {
	    nonnull $objPtr
	    set NULL [my null Interp*]
	    set code [my setFromAny [$api tclBooleanType] $NULL $objPtr]
	    my ret [my eq $code $0]
	}

	label fail:
	    my store $code $ecvar
	    my ret [my fail STRING $code]
	}

	##### Function tcl.existsOrError #####
	#
	# Type signature: exists:bool * message:STRING * ecvar:int* -> bool
	#
	# Conditionally generates an error about a non-existing variable.
	# Generated like this to avoid introducing extra basic blocks at the
	# pre-optimized LLVM level.

	set f [$module local "tcl.existsOrError" bool<-bool,STRING,STRING,int*]
	params exists message exception ecvar
	build {
	    noalias $message $ecvar
	    nonnull $message $exception $ecvar
	    my condBr $exists $doError $done
	label doError:
	    my initException $exception $message $ecvar
	    my br $done
	label done:
	    my ret $exists
	}

	##### Function tcl.not.string #####
	#
	# Type signature: value:STRING * ecvar:int* -> bool?
	#
	# Quadcode implementation ('not').
	#
	# Logical negation of 'value'.

	set f [$m local "tcl.not.string" bool?<-STRING,int*]
	params value ecvar
	build {
	    noalias $ecvar
	    nonnull $value $ecvar
	    set bvar [my alloc int]
	    set interp [$api tclInterp]
	    set code [$api Tcl_GetBooleanFromObj $interp $value $bvar]
	    my condBr [my eq $code [Const 0]] $ok $fail
	label fail:
	    my store [Const 1] $ecvar
	    my ret [my fail bool]
	label ok:
	    my ret [my ok [my neq [my load $bvar "bool"] [Const 1]]]
	}

	my VariableHelperFunctions $api
	my @variableFunctions $api
	my @numericConverterFunctions $api

	    }
	    {NOTHING STRING} {
		append body2 { [my undef STRING]}
	    }
	    {{EXPANDED STRING} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED LIST} LIST} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED DICT} DICT} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED INT} INT} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED DOUBLE} DOUBLE} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED NUMERIC} NUMERIC} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EXPANDED {NUMERIC BOOLEAN}} {NUMERIC BOOLEAN}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY DICT} DICT} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY DICT} DICT} {
		append body2 { $} [lindex $f 0]
	    }
	    {DICT STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY DICT} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY LIST} STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {EMPTY {EMPTY LIST}} {
		append body2 { $} [lindex $f 0]
	    }
	    {EMPTY {EMPTY DICT}} {
		append body2 { $} [lindex $f 0]
	    }
	    {LIST STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY LIST} LIST} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY LIST} LIST} {
		append body2 { $} [lindex $f 0]
	    }
	    {DICT LIST} {
		append body2 { $} [lindex $f 0]
	    }
	    {{EMPTY DICT} {EMPTY LIST}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE DICT} {IMPURE LIST}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE EMPTY DICT} {IMPURE EMPTY LIST}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{NEXIST DICT} {NEXIST STRING}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{NEXIST LIST} {NEXIST STRING}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{NEXIST EMPTY DICT} {NEXIST STRING}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{NEXIST EMPTY LIST} {NEXIST STRING}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{FAIL DICT} {FAIL STRING}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{FAIL LIST} {FAIL STRING}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{FAIL EMPTY DICT} {FAIL STRING}} {
		append body2 { $} [lindex $f 0]
	    }
	    {{FAIL EMPTY LIST} {FAIL STRING}} {
		append body2 { $} [lindex $f 0]
	    }
	}

	foreach type {
	    BOOLEAN
	    ZEROONE {ZEROONE BOOLEAN}
	    INT {INT BOOLEAN}
	    DOUBLE

    #	FOLLOWS STANDARD TclOO PROTOCOL
    #
    # Side effects:
    # 	May create a method. May perform a tailcall (beware if attempting to
    # 	wrap with a filter!)

    method unknown {methodName args} {
	set BASIC_REFTYPES {STRING LIST {EMPTY LIST} DICT {EMPTY DICT}}
	switch -regexp -matchvar match -- $methodName {
	    {^addReference\(FAIL[ _]IMPURE (.*)\)$} {
		lassign $match -> utype
		if {$utype ni $BASIC_REFTYPES} {
		    oo::objdefine [self] method $methodName {value} \
			[string map [list @utype $utype] {
			    set sval [my impure.string [my unmaybe $value]]
			    my impure.maybeAddReference [my maybe $value] $sval
			}]
		    tailcall my $methodName {*}$args
		}
	    }
	    {^dropReference\(FAIL[ _]IMPURE[ _](.*)\)$} {
		lassign $match -> utype
		if {$utype ni $BASIC_REFTYPES} {
		    oo::objdefine [self] method $methodName {value} \
			[string map [list @utype $utype] {
			    my select [my maybe $value] \
				[Const false bool] \
				[my addReference(STRING) \
				     [my impure.string [my unmaybe $value]]]
			}]
		    tailcall my $methodName {*}$args
		}
	    }
	    {^addReference\(IMPURE[ _](.*)\)$} {
		lassign $match -> utype
		if {$utype ni $BASIC_REFTYPES} {
		    oo::objdefine [self] method $methodName {value} \
			[string map [list @utype $utype] {
			    my addReference(STRING) [my impure.string $value]
			}]
		    tailcall my $methodName {*}$args
		}
	    }
	    {^dropReference\(IMPURE[ _](.*)\)$} {
		lassign $match -> utype
		if {$utype ni $BASIC_REFTYPES} {
		    oo::objdefine [self] method $methodName {value} \
			[string map [list @utype $utype] {
			    my dropReference(STRING) [my impure.string $value]
			    # How to determine whether the underlying type is
			    # itself a reference type? (Maybe never?)
			    #my {dropReference(@utype)} [my impure.value $value]
			}]
		    tailcall my $methodName {*}$args
		}
	    }
	}
	if {[my MakeTypecastWrapper $methodName]} {
	    tailcall my $methodName {*}$args

	}
	next $methodName {*}$args
    }
    unexport unknown

    # Builder:MakeTypecastWrapper --
    #

	    $b condBr [$b maybe $result] $isFail $next
	    $isFail build $b {
		$b ret [$b extract $result 0]
	    }
	    $next build-in $b
	    set result [$b unmaybe $result]
	}
	set resultType [string map {
	    {EMPTY STRING} STRING
	} [string map {DICT STRING LIST STRING} $resultType]]
	if {[regexp "^IMPURE (.*)" $resultType -> payload]} {
	    if {$payload ne "STRING"} {
		set result [$b impure.string $result]
		SetValueName $result @result
	    }
	    set resultType STRING
	}
	upvar 0 thunk.result.$resultType thunkResultMapper
	if {![info exist thunkResultMapper]} {
	    error "unhandled result type: $resultType"
	}
	$b call $thunkResultMapper [list $interp $result]

		    return [ConstInt [Type bool] 1 0]
		}
		if {[string is false -strict $value]} {
		    return [ConstInt [Type bool] 0 0]
		}
		error "invalid boolean value \"$value\""
	    }
	    "^STRING$" - "^(?:EMPTY )?(?:LIST|DICT)$" - "^EMPTY$" {
		variable thunkBuilder
		set theObj [$thunkBuilder obj.constant $value]
		return $theObj
	    }
	    {^LLVMTypeRef_\d+$} {
		switch [GetTypeKind $type] {
		    LLVMIntegerTypeKind {

	    ^long$ {
		# Machine word
		return [IntType [expr {$::tcl_platform(wordSize) * 8}]]
	    }
	    {^int(\d+)$} {
		return [IntType [lindex $m 1]]
	    }
	    ^STRING$ - {^(EMPTY )?(LIST|DICT)$} - ^EMPTY$ {
		return [Type named{Tcl_Obj}*]
	    }
	    ^ZEROONE$ - ^BOOLEAN$ - "^ZEROONE BOOLEAN$" {
		return [Type bool]
	    }
	    ^INT$ - ^ENTIER$ - "^INT BOOLEAN$" {
		return [Type named{INT,kind:int1,i32:int,i64:int64}]

		return [Type "FAIL NEXIST [lindex $m 1]"]
	    }
	    {^(.*) FAIL$} - {^FAIL (.*)} - {^(.*)\?$} {
		return [Type struct{int,[Type [lindex $m 1]]}]
	    }
	    {^NEXIST (.*)$} - {^(.*)\!$} {
		return [Type struct{bool,[Type [lindex $m 1]]}]
	    }
	    {^IMPURE (?:EMPTY )?(LIST|DICT)$} {
		return [Type [lindex $m 1]]
	    }
	    {^IMPURE (.*)$} - {^<(.*)>$} {
		return [Type struct{STRING,[Type [lindex $m 1]]}]
	    }
	    {\*$} {
		return [PointerType [Type [string range $t 0 end-1]] 0]
	    }

set msg "Cryptographic Forum Research Group"
set tag [fromHex {a8:06:1d:c1:30:51:36:c6:c2:2b:8b:af:0c:01:27:a9}]

# A simple helper that is not compiled, but rather just shortens code below

proc cleanopt {script} {
    variable cleanopt
    set badopts {-errorinfo -errorstack}
    set code [uplevel 1 [list catch $script cleanopt(msg) cleanopt(opt)]]
    set msg $cleanopt(msg)
    set opt $cleanopt(opt)
    if {[dict exists $opt -during]} {
	dict set opt -during [lsort -stride 2 -dictionary -index 0 \
		[dict remove [dict get $opt -during] -during {*}$badopts]]
    }
    list $code $msg [lsort -stride 2 -dictionary -index 0 \
	    [dict remove $opt {*}$badopts]]
}
proc cleaneropt {script} {
    variable cleanopt
    set badopts {-errorinfo -errorstack -errorline -errorcode}
    set code [uplevel 1 [list catch $script cleanopt(msg) cleanopt(opt)]]
    set msg $cleanopt(msg)
    set opt $cleanopt(opt)
    if {[dict exists $opt -during]} {
	dict set opt -during [lsort -stride 2 -dictionary -index 0 \
		[dict remove [dict get $opt -during] -during {*}$badopts]]

    }
    list $code $msg [lsort -stride 2 -dictionary -index 0 \
	    [dict remove $opt {*}$badopts]]
}

#########################################################################
#
# List of demonstration scripts. Each of these will be executed before and
# after having the compilation engine applied; the output values from before
# and after will be compared, and if they match, the performance ratio will be

    {expandtest::test1}
    {expandtest::test2}
    {expandtest::test3}
    # {expandtest::test5}   Needs support for loop exception ranges
    {expandtest::test6 {a b c d e} {2 2} x}
    {expandtest::test7}
    {expandtest::test8}
    {cleaneropt {expandtest::test9}}
    {cleaneropt {expandtest::test10}}
    {cleaneropt {expandtest::test11}}
    {cleaneropt {expandtest::test12}}

    {bug-0616bcf08e::msrange 0 10}
    {bug-0616bcf08e::msrange2 0 10}
    {singleton::lforeach}
    {singleton::llindex}
    {singleton::srange}
    {qsort {3 6 8 7 0 1 4 2 9 5}}

		set value [list temp [incr depth -1]]
		set r [list temp $depth]
		my generate-arith-domain-check $pc [lindex $insn 0] $value
		my quads purify {temp opd0} $value
		set op [lindex $insn 0]
		my quads $op $r {temp opd0}
	    }
	    listIn - listNotIn {
		set v1 [list temp [incr depth -1]]
		set v0 [list temp [incr depth -1]]
		set r $v0
		my generate-list-domain-check $pc [lindex $insn 0] $v0
		my quads purify {temp opd0} $v0
		my error-quads $pc listIn $r {temp opd0} $v1
		if {[lindex $insn 0] eq "listNotIn"} {
		    my quads not $r $r
		}
	    }
	    div - expon - mod {
		set v1 [list temp [incr depth -1]]
		set v0 [list temp [incr depth -1]]
		set r $v0
		my generate-arith-domain-check $pc [lindex $insn 0] $v0 $v1
		my quads purify {temp opd0} $v0
		my quads purify {temp opd1} $v1
		my error-quads $pc [lindex $insn 0] $r {temp opd0} {temp opd1}
	    }
	    strindex {
		set v1 [list temp [incr depth -1]]
		set v0 [list temp [incr depth -1]]
		set r $v0
		my error-quads $pc [lindex $insn 0] $r $v0 $v1
	    }
	    regexp {
		set flag [list literal [lindex $insn 1]]
		set v1 [list temp [incr depth -1]]
		set v0 [list temp [incr depth -1]]
		set r $v0
		my error-quads $pc regexp $r $flag $v0 $v1
	    }
	    lsetFlat {
		set old [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set indices {}
		for {set i 0} {$i < [lindex $insn 1]-2} {incr i} {
		    lappend indices [list temp [incr depth -1]]
		}
		my generate-list-domain-check $pc [lindex $insn 0] $old
		my quads purify {temp opd0} $old
		set new [list temp $depth]
		my error-quads $pc listSet $new {temp opd0} $elem {*}[lreverse $indices]
	    }
	    lsetList {
		set old [list temp [incr depth -1]]
		set elem [list temp [incr depth -1]]
		set idx [list temp [incr depth -1]]
		set new [list temp $depth]
		my generate-list-domain-check $pc [lindex $insn 0] $old
		my quads purify {temp opd0} $old
		my error-quads $pc listSet $new {temp opd0} $elem $idx
	    }
	    strmatch {
		set flag [list literal [lindex $insn 1]]
		set v1 [list temp [incr depth -1]]
		set v0 [list temp [incr depth -1]]
		set r $v0
		my quads [lindex $insn 0] $r $flag $v0 $v1

		dict with aux {}
		set n [expr {$depth - [llength $assign] - 1}]
		set lists {}
		foreach group $assign {
		    lappend lists [list temp [incr n]]
		}
		set res [list temp $depth]
		foreach list $lists {
		    my generate-list-domain-check $pc [lindex $insn 0] $list
		    my quads purify $list $list
		}
		my error-quads $pc foreachStart $res [list literal $assign] {*}$lists
		foreach list $lists {
		    my quads unshareList $list $list
		}
		my generate-jump [expr {$pc + 5 - $jumpOffset}]
	    }
	    foreach_step {

		set var [my index-to-var [lindex $insn 1]]
		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 generate-dict-domain-check $pc [lindex $insn 0] $dict
		my quads purify {temp opd0} $dict
		my quads dictIterStart $var {temp opd0}
		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-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-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify {temp opd0} $var
		set var {temp opd0}
		set auxNum [string range [lindex $insn 2] 1 end]
		set aux [lindex [dict get $bytecode auxiliary] $auxNum]
		set mid [list temp opnd1]
		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 quads 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]
		set mid [list temp opnd3]
		set updating [list temp opnd4]
		set val [list temp [incr depth -1]]
		set idx 0
		my generate-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't write \"%s\": variable is array"
		my generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify $updating $var
		foreach v [dict get $aux variables] {
		    set r [my index-to-var $v]
		    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 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 quads 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 arrayUnset $ary $ary $idx
	    }
	    dictDone {
		# Do nothing; general free will clean up.
	    }
	    verifyDict {
		set r [list temp [incr depth -1]]
		my generate-dict-domain-check $pc [lindex $insn 0] $r

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

		# 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 list in $var
		my generate-list-domain-check $pc [lindex $insn 0] $listvalue
		my quads purify {temp opd1} $listvalue
		my error-quads $pc directLappendList $var $var {temp opd1}
	    }
	    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 generate-list-domain-check $pc [lindex $insn 0] $listvalue
		my quads purify {temp opd2} $listvalue
		my error-quads $pc \
		    directArrayLappendList $var $var $elem {temp opd2}
	    }
	    existStk {
		set var [list temp [incr depth -1]]
		# TODO: This assumes we're dealing with qualified names!
		my quads directExists $var $var
	    }
	    existArrayStk {

		set q {}
		for {set i 0} {$i < $idxNum} {incr i} {
		    # NOTE: Reversed
		    lappend q [list temp [incr depth -1]]
		}
		set val [list temp [incr depth -1]]
		set r [list temp $depth]
		my generate-dict-domain-check $pc [lindex $insn 0] $val
		my quads purify {temp opd0} $val
		my error-quads $pc dictGet $r {temp opd0} {*}[lreverse $q]
	    }
	    dictExists {
		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 val [list temp [incr depth -1]]
		set r [list temp $depth]
		my generate-dict-domain-check $pc [lindex $insn 0] $val
		my quads purify {temp opd0} $val
		my quads dictExists $r {temp opd0} {*}[lreverse $q]
	    }
	    dictSet {
		set idxNum [expr [lindex $insn 1]]
		set var [my index-to-var [lindex $insn 2]]
		set val [list temp [incr depth -1]]
		set vartmp {temp opd0}
		set q {}
		for {set i 0} {$i < $idxNum} {incr i} {
		    # NOTE: Reversed
		    lappend q [list temp [incr depth -1]]
		}

		my generate-scalar-check $pc $var {TCL READ VARNAME} \
		    "can't read \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify $vartmp $var
		if {[llength $q] == 1} {
		    my quads dictSet $vartmp $vartmp $val {*}$q
		} else {
		    my error-quads $pc dictSet $vartmp $vartmp $val {*}[lreverse $q]
		}
		my quads copy $var $vartmp
	    }
	    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 generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify {temp opd0} $var
		if {[llength $q] == 1} {
		    my quads dictUnset $r {temp opd0} {*}$q
		} else {
		    my error-quads $pc dictUnset $r {temp opd0} {*}[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 generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify {temp opd0} $var
		if {[lindex $insn 0] eq "dictAppend"} {
		    my quads [lindex $insn 0] $res {temp opd0} $key $val
		} else {
		    # dictLappend can fail if value in dict is non-list
		    my error-quads $pc [lindex $insn 0] $res {temp opd0} $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 generate-dict-domain-check $pc [lindex $insn 0] $var
		my quads purify {temp opd0} $var
		my error-quads $pc dictIncr $res {temp opd0} $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} {
		    lappend qd [list temp [expr {$depth + $i}]]
		}
		my quads list $result {*}$qd
	    }
	    listIndexImm {
		set idx [list literal [string range [lindex $insn 1] 1 end]]
		set val [list temp [incr depth -1]]
		my generate-list-domain-check $pc [lindex $insn 0] $val
		my quads purify {temp opd0} $val
		my error-quads $pc listIndex $val {temp opd0} $idx
	    }
	    listIndex {
		set idx [list temp [incr depth -1]]
		set val [list temp [incr depth -1]]
		my generate-list-domain-check $pc [lindex $insn 0] $val
		my quads purify {temp opd0} $val
		my error-quads $pc listIndex $val {temp opd0} $idx
	    }
	    lindexMulti {
		set n [lindex $insn 1]
		set val [list temp [incr depth -$n]]
		for {set i 1} {$i < $n} {incr i} {
		    my generate-list-domain-check $pc [lindex $insn 0] $val
		    my quads purify $val $val
		    my error-quads $pc listIndex $val $val [list temp [incr depth]]
		}
		# Should we do this as a single operation? c.f. TclLindexFlat
	    }
	    listRangeImm {
		set from [list literal [string range [lindex $insn 1] 1 end]]
		set to [list literal [string range [lindex $insn 2] 1 end]]
		set val [list temp [incr depth -1]]
		my generate-list-domain-check $pc [lindex $insn 0] $val
		my quads purify {temp opd0} $val
		my error-quads $pc listRange $val {temp opd0} $from $to
	    }
	    listLength {
		set value [list temp [incr depth -1]]
		set r [list temp $depth]
		my generate-list-domain-check $pc [lindex $insn 0] $value
		my quads purify {temp opd0} $value
		my error-quads $pc [lindex $insn 0] $r {temp opd0}
	    }
	    invokeReplace {
		set acount [lindex $insn 1]
		set rcount [lindex $insn 2]
		set depth [expr {$depth - $acount - 1}]
		set result [list temp $depth]
		# FIXME - Simply do the replacement in place for

	    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-scalar-check $pc $var {TCL WRITE VARNAME} \
		    "can't set \"%s\": variable is array"
		my quads initIfNotExists $var $var {literal {}}
		my generate-list-domain-check $pc [lindex $insn 0] $var
		my quads purify $var $var
		my quads 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 {}}
		my generate-list-domain-check $pc [lindex $insn 0] $var
		my quads purify $var $var
		my generate-list-domain-check $pc [lindex $insn 0] $listval
		my quads purify $listval $listval
		my quads 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 generate-list-domain-check $pc [lindex $insn 0] $inval
		my quads purify $inval $inval
		my quads 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 {}}
		my generate-list-domain-check $pc [lindex $insn 0] $inval
		my quads purify $inval $inval
		my generate-list-domain-check $pc [lindex $insn 0] $listval
		my quads purify $listval $listval
		my quads 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]
		my generate-list-domain-check $pc [lindex $insn 0] $list1
		my quads purify {temp opd0} $list1
		my generate-list-domain-check $pc [lindex $insn 0] $list2
		my quads purify {temp opd1} $list2
		my error-quads $pc listConcat $res {temp opd0} {temp opd1}
	    }
	    arrayExistsImm {
		set ary [my index-to-var [lindex $insn 1]]
		set res [list temp $depth]
		my quads arrayExists $res $ary
	    }
	    arrayMakeImm {

    my quads extractFail {temp @exception} {temp @exception}
    # 4
    my generate-jump $fail
    # 5

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

# generate-list-domain-check / generate-dict-domain-check --
#
#	Generates a check to make sure that a value is LIST or DICT
#	for the instructions that require such a value.  Do not call from
#	anywhere but bytecode-to-quads!
#
# Parameters:
#	q - The quadruple that will consume the value
#
# Results:
#	None.
#
# Side effects:
#	Emits a the appropriate sequence of 'instanceOf', 'jumpTrue',
#	'initException', 'jump'.

oo::define quadcode::transformer method generate-list-domain-check {pc inst val} {
    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

    namespace upvar ::quadcode::dataType LIST typecode IMPURE impure
    set impureTC [::quadcode::dataType::typeUnion $typecode $impure]
    set opc [list instanceOf $impureTC {IMPURE LIST}]

    my quads $opc {temp @ok} $val
    my quads jumpTrue $ok {temp @ok}
    set msg [format {can't use non-list string as operand of "%s"} $inst]
    set msgLit [list literal $msg]
    set opts {literal {-errorcode {ARITH DOMAIN {non-numeric string}}}}
    my quads initException {temp @exception} \
	$msgLit $opts {literal 1} {literal 0}
    my quads extractFail {temp @exception} {temp @exception}
    my generate-jump $fail
}

oo::define quadcode::transformer method generate-dict-domain-check {pc inst val} {
    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

    namespace upvar ::quadcode::dataType DICT typecode IMPURE impure
    set impureTC [::quadcode::dataType::typeUnion $typecode $impure]
    set opc [list instanceOf $impureTC {IMPURE DICT}]

    my quads $opc {temp @ok} $val
    my quads jumpTrue $ok {temp @ok}
    set msg [format {can't use non-list string as operand of "%s"} $inst]
    set msgLit [list literal $msg]
    set opts {literal {-errorcode {ARITH DOMAIN {non-numeric string}}}}
    my quads initException {temp @exception} \
	$msgLit $opts {literal 1} {literal 0}
    my quads extractFail {temp @exception} {temp @exception}
    my generate-jump $fail
}

# generate-arith-domain-check --
#
#	Generates a check to make sure that a value is NUMERIC or INT
#	for the instructions that require such a value.  Do not call from
#	anywhere but bytecode-to-quads!
#

namespace eval quadcode::dataType {

    namespace export mightbea isa allbut typeIntersect typeUnion

    # IMPURE - Any value that has a known internal representation may
    #          have the IMPURE indicator to show that it has a string
    #          representation that must be preserved.

    variable IMPURE		[expr 0x4000000]

    # BOTTOM - means an inconsistency. We have contradictory information
    #          about a given value. Should not happen.

    variable BOTTOM		0

    variable NUMERIC		[expr {$DOUBLE | $ENTIER}]

    # NUMERIC_OR_BOOLEAN - the value is a number, or some spelling of
    #                      'true' or 'false'

    variable NUMERIC_OR_BOOLEAN	[expr {$NUMERIC | $BOOLEAN}]

    # NONEMPTYDICT - the value is a non-empty dictionary of some sort. The
    #		types of the keys and the values are just STRING.

    variable NONEMPTYDICT	[expr 0x200]

    # NONDICTLIST - the value is a list of some sort that isn't a dictionary
    #		but isn't empty. The type of the elements is just STRING.

    variable NONDICTLIST	[expr 0x100]

    # LIST - the value is a list of some sort. The type of the elements is
    #		just STRING. Note that a DICT is also a LIST.

    variable LIST		[expr {$NONDICTLIST | $NONEMPTYDICT | $EMPTY}]

    # DICT - the value is a dict of some sort. The type of the keys and values
    #		are just STRING. Note that a DICT is also a LIST.

    variable DICT		[expr {$NONEMPTYDICT | $EMPTY}]

    # FOREACH - the value represents the iterator of a [foreach] or [lmap].
    #           There are no constants of this type, and it is therefore
    #           always pure.

    variable FOREACH		[expr 0x10000]

	FAIL			FAIL
	ARRAY			ARRAY
	DICTITER		DICTITER
	FOREACH			FOREACH
	EXPANDED		EXPANDED
	OTHERSTRING		STRING
	IMPURE			IMPURE
	NONDICTLIST		LIST
	NONEMPTYDICT		DICT
	EMPTY			EMPTY
    } {
	namespace upvar dataType $name t
	if {$type & $t} {
	    namespace upvar dataType $wname w
	    lappend result $wname
	    set type [expr {$type & ~$w}]

oo::define quadcode::transformer method typeOfResult {q} {
    namespace upvar ::quadcode::dataType {*}{
	DOUBLE DOUBLE INT INT STRING STRING FAIL FAIL EMPTY EMPTY
	ZEROONE ZEROONE
	BOOL_INT BOOL BOOLWORD BOOLWORD
	ENTIER ENTIER NUMERIC NUMERIC IMPURE IMPURE
	VOID VOID CALLFRAME CALLFRAME DICTITER DICTITER FOREACH FOREACH
	ARRAY ARRAY NEXIST NEXIST EXPANDED EXPANDED LIST LIST DICT DICT
    }

    switch -exact -- [lindex $q 0 0] {
	debug-value {
	    return [typeOfOperand $types [lindex $q 3]]
	}
	widenTo {

	eq -
	ge -
	gt -
	instanceOf -
	isBoolean -
	land -
	le -
	listIn -
	lor -
	lt -
	neq -
	strclass -
	streq -
	strmatch -
	strneq {
	    return $ZEROONE
	}
	not {
	    set t [typeOfOperand $types [lindex $q 2]]
	    if {istype($t,$NUMERIC|$BOOLWORD)} {
		return $ZEROONE
	    } else {
		puts "which might FAIL"
		return [expr {$ZEROONE | $FAIL}]
	    }
	}
	regexp {
	    return [expr {$ZEROONE | $FAIL}]
	}
	listLength - dictSize {
	    return $INT
	}
	phi {
	    set r 0
	    foreach {from operand} [lrange $q 2 end] {
		set r [expr {$r | [typeOfOperand $types $operand]}]
	    }
	    return $r

	    # Simple numbers are simple words when not IMPURE
	    if {istype($t1,$NUMERIC) && !($t1 & $IMPURE)} {
		return $t1
	    }
	    return [expr {$EXPANDED | $t1}]
	}
	verifyList {
	    return [expr {$FAIL | $LIST}]
	}
	invoke {
	    # We know the result type of a handful of the things
	    # that might be invoked
	    if {[lindex $q 3 0] eq "literal"} {
		set rtype [my typeOfInvoke [lindex $q 3 1] [lrange $q 4 end]]
	    } else {

	    # Pull from the callframe of the earlier 'invoke'
	    return [expr {[typeOfOperand $types [lindex $q 2]] & ~$CALLFRAME}]
	}
	extractCallFrame {
	    # Trim the non-callframe part
	    return $CALLFRAME
	}
	list - unshareList {
	    return $LIST
	}
	returnOptions {
	    return $DICT
	}
	result - dictIterKey - dictIterValue -
	concat - strcat - strmap - strtrim - strcase {
	    return $STRING
	}
	foreachAdvance {
	    return $FOREACH
	}
	foreachStart {
	    return [expr {$FOREACH | $FAIL}]
	}
	listAppend - listConcat {
	    return $LIST
	}
	listIndex {
	    if {[llength $q] == 4} {
		set t2 [typeOfOperand $types [lindex $q 3]]
		# TODO: have end-relative indices be their own type
		if {istype($t2, $INT) || istype($t2, $ZEROONE)} {
		    return $STRING
		}
	    } elseif {[llength $q] == 3} {
		return [typeOfOperand $types [lindex $q 2]]
	    }
	    return [expr {$STRING | $FAIL}]
	}
	listRange {
	    set t1 [typeOfOperand $types [lindex $q 3]]
	    set t2 [typeOfOperand $types [lindex $q 4]]
	    # TODO: have end-relative indices be their own type
	    if {(istype($t1, $INT) || istype($t1, $ZEROONE)) &&
		    (istype($t2, $INT) || istype($t2, $ZEROONE))} {
		return $LIST
	    }
	    return [expr {$LIST | $FAIL}]
	}
	listSet {
	    return [expr {$LIST | $FAIL}]
	}
	strindex - strrange - strreplace - dictGet {
	    # TODO: have end-relative indices be their own type and be non-failing
	    return [expr {$STRING | $FAIL}]
	}
	dictSetOrUnset - dictAppend {
	    return $DICT
	}
	dictUnset {
	    if {[llength $q] == 4} {
		return $DICT
	    } else {
		return [expr {$DICT | $FAIL}]
	    }
	}
	dictSet {
	    if {[llength $q] == 5} {
		return $DICT
	    } else {
		return [expr {$DICT | $FAIL}]
	    }
	}
	dictIncr - dictLappend {
	    return [expr {$DICT | $FAIL}]
	}
	dictGetOrNexist {
	    return [expr {$STRING | $NEXIST}]
	}
	arrayGet {
	    return [expr {$STRING | $NEXIST}]
	}
	arraySet - arrayUnset - initArray {
	    return $ARRAY
	}
	dictIterStart - dictIterNext {



	    return $DICTITER
	}
	initIfNotExists {
	    set vartype [typeOfOperand $types [lindex $q 2]]
	    set deftype [typeOfOperand $types [lindex $q 3]]
	    return [expr {$deftype | ($vartype & ~$NEXIST)}]
	}

	if {$y eq $x} {
	    return $dataType::DOUBLE
	} else {
	    return [dataType::typeUnion $dataType::DOUBLE $dataType::IMPURE]
	}
    } elseif {[string is boolean -strict $x]} {
	return [dataType::typeUnion $dataType::BOOLEAN $dataType::IMPURE]
    } elseif {[string is list $x] && ($x eq [list {*}$x])} {
	# Purity is determined by seeing if the string value could be made by
	# [list]; if not, we've got a value with extra whitespace we should
	# preserve.

	# We claim that lists of length one are simple STRINGs; that's usually
	# a more honest choice.
	if {[llength $x] <= 1} {
	    return $dataType::IMPUREOTHERSTRING
	}
	# Odd-length LISTs cannot be DICTs, and we prefer to not call them
	# DICTs if they have non-unique keys.
	if {([llength $x] & 1) == 0 && [dict create {*}$x] eq $x} {
	    return $dataType::NONEMPTYDICT
	} else {
	    return $dataType::NONDICTLIST
	}
    } else {
	return $dataType::IMPUREOTHERSTRING
    }
}

# builtinCommandType -
#