# Results:
    #	A boolean (int1) LLVM value reference.

    method isNumericInt {NUMERIC {name ""}} {
	my eq [my extract $NUMERIC NUMERIC.kind] \
	    [Const ${::LLVM::NUMERIC.type.int} int1] $name
    }

    # Builder: getNumericBooleanKind
    #
    #	Generate code to return the kind of a NUMERIC BOOLEAN
    #
    # Parameters:
    #	nb - The NUMERIC BOOLEAN vlaue reference
    #	name (optional) - A name to give to the result
    #
    # Results:
    #	An int(3) LLVM value reference: 0 = INT, 1 = DOUBLE 2 = BOOLEAN

    method getNumericBooleanKind {nb {name ""}} {
	my extract $nb NUMERIC_BOOLEAN.kind
    }

    # Builder:packInt32 --
    #
    #	Generate code to convert an int32 to an INT.
    #
    # Parameters:
    #	value -	The 32-bit integer LLVM value reference.

    #	The NUMERIC LLVM value reference.

    method packNumericDouble {value {name ""}} {
	my insert [my insert [my undef NUMERIC] \
		[Const ${::LLVM::NUMERIC.type.double} int1] NUMERIC.kind] \
	    $value NUMERIC.double $name
    }

    # Builder:packNumericOrBooleanInt --
    #
    #	Generate code to convert an integer to a NUMERIC BOOLEAN
    #
    # Parameters:
    #	value - The integer LLVM value reference
    #   name (optional) - A name to give to the result value
    #
    # Results:
    #	The NUMERIC BOOLEAN LLVM value reference

    method packNumericOrBooleanInt {value {name ""}} {
	my insert [my insert [my undef "NUMERIC_BOOLEAN"] \
		       [Const ${::LLVM::NUMERIC_BOOLEAN.type.int} int3] \
		       NUMERIC_BOOLEAN.kind] \
	    $value NUMERIC_BOOLEAN.int $name
    }

    # Builder:packNumericOrBooleanDouble --
    #
    #	Generate code to convert a double to a NUMERIC BOOLEAN
    #
    # Parameters:
    #	value - The DOUBLE LLVM value reference
    #	name (optional) - A name to give to the result value
    #
    # Results:
    #	The NUMERIC BOOLEAN LLVM value reference

    method packNumericOrBooleanDouble {value {name ""}} {
	my insert [my insert [my undef "NUMERIC_BOOLEAN"] \
		       [Const ${::LLVM::NUMERIC_BOOLEAN.type.double} int3] \
		       NUMERIC_BOOLEAN.kind] \
	    $value NUMERIC_BOOLEAN.double $name
    }

    # Builder:packNumericOrBooleanBoolean --
    #
    #	Generate code to convert a Boolean to a NUMERIC BOOLEAN
    #
    # Parameters:
    #	value - The bool LLVM value reference
    #	name (optional) - A name to give to the result value
    #
    # Results:
    #	The NUMERIC BOOLEAN LLVM value reference

    method packNumericOrBooleanBoolean {value {name ""}} {
	my insert [my insert [my undef "NUMERIC_BOOLEAN"] \
		       [Const ${::LLVM::NUMERIC_BOOLEAN.type.bool} int3] \
		       NUMERIC_BOOLEAN.kind] \
	    $value NUMERIC_BOOLEAN.bool $name
    }

    # Builder:int.32 --
    #
    #	Generate code to extract the int32 from an INT. Caller MUST guarantee
    #	that the size was tested for first.
    #
    # Parameters:

    #
    # Results:
    #	A DOUBLE LLVM value reference.

    method numeric.double {NUMERIC {name ""}} {
	my extract $NUMERIC NUMERIC.double $name
    }

    # Builder:numericOrBoolean.int --
    #
    #	Generate code to extract the INT from a NUMERIC BOOLEAN. Caller MUST
    #	guarantee that the kind was tested for first.
    #
    # Parameters:
    #	nb - LLVM NUMERIC BOOLEAN value reference
    #	name (optional) - A name to give to the result
    #
    # Results:
    #	An INT LLVM value reference

    method numericOrBoolean.int {nb {name ""}} {
	my extract $nb NUMERIC_BOOLEAN.int $name
    }

    # Builder:numericOrBoolean.double --
    #
    #	Generate code to extract the DOUBLE from a NUMERIC BOOLEAN. Caller MUST
    #	guarantee that the kind was tested for first.
    #
    # Parameters:
    #	nb - LLVM NUMERIC BOOLEAN value reference
    #	name (optional) - A name to give to the result
    #
    # Results:
    #	A DOUBLE LLVM value reference

    method numericOrBoolean.double {nb {name ""}} {
	my extract $nb NUMERIC_BOOLEAN.double $name
    }

    # Builder:numericOrBoolean.bool --
    #
    #	Generate code to extract the BOOLEAN from a NUMERIC BOOLEAN. Caller MUST
    #	guarantee that the kind was tested for first.
    #
    # Parameters:
    #	nb - LLVM NUMERIC BOOLEAN value reference
    #	name (optional) - A name to give to the result
    #
    # Results:
    #	An int1 LLVM value reference

    method numericOrBoolean.bool {nb {name ""}} {
	my extract $nb NUMERIC_BOOLEAN.bool $name
    }

    # Builder:NumToDbl --
    #
    #	Generate code to convert a NUMERIC to a DOUBLE. The value inside the
    #	NUMERIC might be INT or DOUBLE; this handles both cases.
    #
    # Parameters:

    method instanceOf.NUMERIC(STRING) {value {name ""}} {
	my call ${tcl.isNumeric} [list $value [Const false bool]] $name
    }
    method instanceOf.IMPURE_NUMERIC(STRING) {value {name ""}} {
	my call ${tcl.isNumeric} [list $value [Const false bool]] $name
    }

    # Builder:instanceOf.NUMERIC_OR_BOOLEAN --
    #
    #	Generate code to check if the given STRING contains something that
    #	can be parsed to get either a NUMERIC or a BOOLEAN (suitable, in
    #	other words, for a conditional. Quadcode implementation ('jumpFalse',
    #	'jumpTrue', 'land', 'lor', 'not')

    method instanceOf.NUMERIC_OR_BOOLEAN(STRING) {value {name ""}} {
	my call ${tcl.isNumericOrBoolean} [list $value] $name
    }
    method instanceOf.IMPURE_NUMERIC_OR_BOOLEAN(STRING) {value {name ""}} {
	my call ${tcl.isNumericOrBoolean} [list $value] $name
    }

    # Builder:instanceOf.ZEROONE_BOOLEAN --
    #
    #	Generate code to check if the given STRING contains something that
    #	can be parsed to get a ZEROONE or a BOOLEAN (suitable, in
    #	other words, for a conditional. Quadcode implementation ('jumpFalse',
    #	'jumpTrue', 'land', 'lor', 'not')

    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:int --
    #
    #	Generate code to create an integer "literal".
    #
    # Parameters:
    #	value -	The Tcl integer that we are converting to an LLVM INT.

    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	An LLVM INT value reference containing a boolean value.

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

    # Builder:isTrue(INT BOOLEAN) --
    #
    #	Tests whether a given value will cause 'jumpTrue' to jump;
    #	Quadcode implementation('jumpTrue', 'jumpFalse')
    #
    # Parameters:
    #	value - The value to test, as an LLVM value reference.
    #	name (optional) - A name to give to the result value.
    #
    # Results:
    #	An LLVM ZEROONE value reference.

    method isTrue(INT\040BOOLEAN) {value {name ""}} {
	my eq $value [Const 0 int64]
    }

    # Builder:isTrue(DOUBLE) --
    #
    #	Tests whether a given value will cause 'jumpTrue' to jump;
    #	Quadcode implementation('jumpTrue', 'jumpFalse')
    #
    # Parameters:
    #	value - The value to test, as an LLVM value reference.
    #	name (optional) - A name to give to the result value.
    #
    # Results:
    #	An LLVM ZEROONE value reference.

    method isTrue(DOUBLE) {value {name ""}} {
	my eq $value [Const 0.0 double]
    }

    # Builder:isTrue(NUMERIC) --
    #
    #	Tests whether a given value will cause 'jumpTrue' to jump;
    #	Quadcode implementation('jumpTrue', 'jumpFalse')
    #
    # Parameters:
    #	value - The value to test, as an LLVM value reference.
    #	name (optional) - A name to give to the result value.
    #
    # Results:
    #	An LLVM ZEROONE value reference.

    method isTrue(NUMERIC) {value name} {
	my call ${tcl.isTrue.numeric} [list $value] $name
    }

    # Builder:isTrue(NUMERIC BOOLEAN) --
    #
    #	Tests whether a given value will cause 'jumpTrue' to jump;
    #	Quadcode implementation('jumpTrue', 'jumpFalse')
    #
    # Parameters:
    #	value - The value to test, as an LLVM value reference.
    #	name (optional) - A name to give to the result value.
    #
    # Results:
    #	An LLVM ZEROONE value reference.

    method isTrue(NUMERIC\040BOOLEAN) {value name} {
	my call ${tcl.isTrue.numericOrBoolean} [list $value] $name
    }

    # Builder:isTrue(ZEROONE BOOLEAN) --
    #
    #	Tests whether a given value will cause 'jumpTrue' to jump;
    #	Quadcode implementation('jumpTrue', 'jumpFalse')
    #
    # Parameters:
    #	value - The value to test, as an LLVM value reference.
    #	name (optional) - A name to give to the result value.
    #
    # Results:
    #	An LLVM ZEROONE value reference.

    method isTrue(ZEROONE) {value name} {
	return $value
    }
    method isTrue(ZEROONE\040BOOLEAN) {value name} {
	return $value
    }

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

		set idx -1
		foreach value $values type $types {
		    if {[lindex $type 0] eq "IMPURE"} {
			set value [my stringify($type) $value]
		    } else {
			switch -exact -- $type {
			    "INT" - "INT BOOLEAN" - "ZEROONE" - "DOUBLE" -
			    "ENTIER" - "NUMERIC" - "NUMERIC BOOLEAN" {
				set value [my stringify($type) $value]
			    }
			}
		    }
		    my store $value [my gep $vlist [incr idx]]
		}
	    } else {

    method narrowToType.IMPURE_BOOLEAN(IMPURE\040ZEROONE\040BOOLEAN) {value {name ""}} {
	my addReference(STRING) [my impure.string $value]
	if {$name ne "" && [string match {[0-9]*} [GetValueName $value]]} {
	    SetValueName $value $name
	}
	return $value
    }

    # Builder:narrowToType.IMPURE_NUMERIC_BOOLEAN(STRING) --
    #
    #	Generate code to extract IMPURE NUMERIC BOOLEAN from a STRING.
    #
    # Parameters:
    #	value - The STRING to parse
    #	name (optional) - A name to give to the result
    #
    # Results:
    #	An IMPURE NUMERIC BOOLEAN value reference.

    method narrowToType.IMPURE_NUMERIC_BOOLEAN(STRING) {value {name ""}} {
	set nbval [my Call ${tcl.extractNumericOrBoolean} $value]
	my addReference(STRING) $value
	return [my impure NUMERIC_BOOLEAN $value $nbval $name]
    }

    # Builder:narrowToType.IMPURE_ZEROONE(IMPURE ZEROONE BOOLEAN) --
    #
    #	Generate code to extract IMPURE ZEROONE from IMPURE ZEROONE BOOLEAN.
    #	The extracton does nothing except bump the reference count, the two
    #	types have the same internal representation
    #

    #
    # Results:
    #	A NUMERIC LLVM value reference.

    method not(NUMERIC) {value errVar {name ""}} {
	my call ${tcl.not.numeric} [list $value] $name
    }

    # Builder:not(NUMERIC BOOLEAN) --
    #
    #	Generate code to create the logical not of a NUMERIC BOOLEAN. Quadcode
    #	implementation ('not').
    #
    # Parameters:
    #	value -	The NUMERIC LLVM value reference for the operand.
    #	errVar -
    #		Location to write the Tcl return code into, as an LLVM int*
    #		reference. (unused)
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A NUMERIC LLVM value reference.

    method not(NUMERIC\040BOOLEAN) {value errVar {name ""}} {
	my call ${tcl.not.numericOrBoolean} [list $value] $name
    }

    # Builder:not(STRING) --
    #
    #	Generate code to create the logical not of a STRING. Quadcode
    #	implementation ('not').
    #
    # Parameters:

    #
    # Results:
    #	A STRING LLVM value reference.

    method stringify(IMPURE\040INT) {value {name ""}} {
	my stringifyImpure $value $name
    }

    # Builder:stringify(NUMERIC BOOLEAN) --
    #
    #	Generate a STRING representation of a NUMERIC. WARNING: caller is
    #	entirely responsible for reference count management; this method does
    #	not handle that. This method is used by the type promotion code.
    #
    # Parameters:
    #	value -	The NUMERIC LLVM value reference for the operand.
    #	name (optional) -
    #		A name to give to the result value.
    #
    # Results:
    #	A STRING LLVM value reference.

    method stringify(NUMERIC\040BOOLEAN) {value {name ""}} {
	my call ${tcl.stringify.numericOrBoolean} [list $value] $name
    }

    # Builder:stringify(NUMERIC) --
    #
    #	Generate a STRING representation of a NUMERIC. WARNING: caller is
    #	entirely responsible for reference count management; this method does
    #	not handle that. This method is used by the type promotion code.
    #

			    [$b maybe [$b frame.value $res]]
		    }
		    my StoreResult $tgt $res
		}
		"bitor" - "bitxor" - "bitand" - "lshift" - "rshift" -
		"add" - "sub" - "mult" - "uminus" - "uplus" - "land" - "lor" -
		"isBoolean" - "eq" - "neq" - "lt" - "gt" - "le" - "ge" -
		"not" -
		"streq" - "bitnot" - "strcase" - "strclass" - "strcmp" -
		"strfind" - "strlen" - "strmap" - "strmatch" - "strrfind" -
		"strtrim" - "resolveCmd" - "arrayExists" - "directExists" -
		"arrayElementExists" - "directArrayExists" -
		"initArrayIfNotExists" - "extractScalar" - "extractArray" -
		"arraySet" - "arrayUnset" - "arrayGet" {
		    set srcs [lassign $l opcode tgt]

		"directLappendList" - "directUnset" -
		"directArrayGet" - "directArraySet" - "directArrayAppend" -
		"directArrayLappend" - "directArrayLappendList" -
		"directArrayUnset" - "directIsArray" - "directMakeArray" -
		"regexp" - "listAppend" - "listConcat" - "listLength" -
		"listRange" - "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}]
		    set res [$b $opcode {*}$srcs $errorCode $name]
		    if {"FAIL" in [my ValueTypes $tgt]} {

			$b br $block($tgt)
		    }
		}
		"jumpTrue" {
		    lassign $l opcode tgt src
		    set name [my LocalVarName $src]
		    set tgt [lindex $tgt 1]
		    set mth isTrue([my ValueTypes $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 ValueTypes $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

    variable tcl.div tcl.div.32 tcl.div.64 tcl.div.double tcl.mod
    variable tcl.shr tcl.and tcl.or tcl.xor
    variable tcl.eq tcl.ne tcl.lt tcl.le tcl.gt tcl.ge
    variable tcl.not tcl.neg tcl_div
    variable tcl.land tcl.land.double tcl.lor tcl.lor.double
    variable tcl.add.numeric tcl.sub.numeric tcl.mult.numeric tcl.div.numeric
    variable tcl.pow.numeric tcl.land.numeric tcl.lor.numeric tcl.not.numeric
    variable tcl.not.numericOrBoolean
    variable tcl.neg.numeric tcl.eq.numeric tcl.ne.numeric tcl.lt.numeric
    variable tcl.le.numeric tcl.gt.numeric tcl.ge.numeric
    variable tcl.isBoolean tcl.isInteger tcl.isDouble
    variable tcl.isNumeric tcl.isNumericOrBoolean
    variable tcl.isTrue.numerc tcl.isTrue.numericOrBoolean
    variable tcl.isZeroOneBoolean
    variable tcl.extractNumeric tcl.extractNumericOrBoolean
    variable tcl.extractDouble tcl.extractInteger
    variable tcl.stringify.double tcl.stringify.int
    variable tcl.stringify.numeric
    variable tcl.cmp.strstr tcl.cmp.strnum

    # Builder:GrowingBinaryFunction --
    #
    #	Generate a function that implements a (normal) mathematical operator
    #	that can increase the width of its result relative to the width of its
    #	input values. Only called from @supportFunctions method.

	build {
	    my condBr [my isNumericInt $value] $intNot $dblNot
	label intNot "int.not"
	    my ret [my not(INT) [my numeric.int $value] [my null int]]
	label dblNot "double.not"
	    my ret [my not(DOUBLE) [my numeric.double $value] [my null int]]
	}

	##### Function tcl.not.numericOrBoolean #####
	#
	# Type signature: x:NUMERIC\040BOOLEAN -> ZEROONE
	#
	# Quadcode implementation ('not')
	#
	# Logical negation of 'x'.

	set f [$m local "tcl.not.numericOrBoolean" "ZEROONE<-NUMERIC BOOLEAN" \
		   readonly]
	params value
	build {
	    my switch [my getNumericBooleanKind $value] \
		$boolNot 0 $intNot 1 $dblNot
	label intNot "int.not"
	    my ret [my not(INT) [my numericOrBoolean.int $value] [my null int]]
	label dblNot "double.not"
	    my ret [my not(DOUBLE) [my numericOrBoolean.double $value] \
			[my null int]]
	label boolNot "bool.not"
	    my ret [my not [my numericOrBoolean.bool $value]]
	}

	##### Function tcl.neg.numeric #####
	#
	# Type signature: x:NUMERIC -> NUMERIC
	#
	# Quadcode implementation ('neg').
	#

	    my condBr [my isNumericInt $value] $int $double
	label int "op.int"
	    my ret [my Call tcl.stringify.int [my numeric.int $value]]
	label double "op.double"
	    my ret [my Call tcl.stringify.double [my numeric.double $value]]
	}

	##### tcl.stringify.numericOrBoolean #####
	#
	# Type signature: value:NUMERIC BOOLEAN -> STRING
	#
	# Convert 'value' to a zero-refcount string (Tcl_Obj)
	#
	# Notes:
	#	It is puzzling why this needs to happen; somewhere
	#	someone wants one of these stringified and doesn't
	#	have the string rep already?

	# TODO - Fill this in if it's actually needed?
    }

    method @numericConverterFunctions {api} {

	##### Function tcl.impl.isBoolean #####
	##### Closure Build:isBoolean #####
	#
	# Type signature objPtr:STRING -> int1
	#
	# Tests if a STRING is already a wrapped Boolean word
	# (true/false, yes/no, on/off)

	set f [$m local "tcl.impl.isBoolean" int1<-STRING readonly]
	params objPtr
	build {
	    nonnull $objPtr
	    set boolType [$api tclBooleanType]
	    set type [my dereference $objPtr 0 Tcl_Obj.typePtr]
	    my ret [my and [my nonnull $type] [my eq $boolType $type]]
	}
	my closure isBoolean {STRING {name ""}} {
	    my call ${tcl.impl.isBoolean} [list $STRING] $name
	}

	##### Function tcl.impl.isDouble #####
	##### Closure Build:isDouble #####
	#
	# Type signature: objPtr:STRING -> int1
	#
	# Test if a STRING is actually already a wrapped double.

	    set b2 [$api Tcl_GetString $value]
	    SetValueName $b2 "bytes"
	    my br $get
	label get:
	    set bytes [my phi [list $b1 $b2] [list $entry $generate] "bytes"]
	    my ret [my eq [my dereference $bytes 0] [Const 0 int8]]
	}


	##### Function tcl.isNumeric #####
	#
	# Type signature: value:STRING -> ZEROONE
	#
	# Tests if a STRING can be parsed as a NUMERIC. Part of the
	# implementation of quadcode "instanceOf".

	    my condBr [my isInteger $value] $yes $checkEmptyOK
	label checkEmptyOK:
	    my condBr $emptyOK $checkEmpty $checkDouble
	label checkEmpty:
	    my condBr [my Call tcl.impl.strempty $value] $yes $checkDouble
	label checkDouble:
	    set d [my GetDouble $value]
	    my ret [my extract $d 0]
	label yes:
	    my ret [Const true bool]
	}

	##### Function: tcl.isNumericOrBoolean #####
	#
	# Type signature: value:STRING -> ZEROONE
	#
	# Tests if a STRING can be parsed as either a NUMERIC or BOOLEAN
	# (and hence might be an argument to commands like 'if'). Part of
	# the implementation of quadcode 'instanceOf'.

	set f [$m local "tcl.isNumericOrBoolean" ZEROONE<-STRING]
	params value
	build {
	    nonnull $value
	    my condBr [my nonnull [my dereference $value 0 Tcl_Obj.typePtr]] \
		$checkTypes $getDouble
	label checkTypes:
	    my condBr [my isDouble $value] $yes $checkIntType
	label checkIntType:
	    my condBr [my isInteger $value] $yes $checkBooleanType
	label checkBooleanType:
	    my condBr [my isBoolean $value] $yes $getDouble
	label getDouble:
	    set d [my GetDouble $value]
	    my condBr [my extract $d 0] $yes $getBool
	label getBool:
	    set b [my GetBoolean $value]
	    my ret [my extract $b 0]
	label yes:
	    my ret [Const true bool]
	}

	##### Function tcl.isBoolean #####
	#
	# Type signature: value:STRING->ZEROONE
	#
	# Tests if a STRING can be parsed as a BOOLEAN. Part of the
	# implementation of quadcodes 'instanceOf' and 'isBoolean'.

	set f [$m local "tcl.isBoolean" ZEROONE<-STRING,ZEROONE]
	params value emptyOK
	build {
	    nonnull $value
	    my condBr [my isBoolean $value] $yes $checkEmptyOK
	label checkEmptyOK:
	    my condBr $emptyOK $checkEmpty $getBoolean     
        label checkEmpty:
	    my condBr [my Call ${tcl.impl.strempty} $value] $yes $getBoolean
	label getBoolean:
	    set bv [my GetBoolean $value]
	    my ret [my extract $bv 0]
	label yes:
	    my ret [Const true bool]
	}

	##### Function tcl.isDouble #####
	#
	# Type signature: value:STRING -> ZEROONE
	#
	# Tests if a STRING can be parsed as a DOUBLE. Part of the
	# implementation of quadcode "instanceOf".

	set f [$m local "tcl.isDouble" ZEROONE<-STRING,ZEROONE]
	params value emptyOK
	build {
	    nonnull $value
	    my condBr [my isDouble $value] $yes $checkEmptyOK
	label checkEmptyOK:
	    my condBr $emptyOK $checkEmpty $checkDouble
	label checkEmpty:
	    my condBr [my Call ${tcl.impl.strempty} $value] $yes $checkDouble
	label checkDouble:
	    set d [my GetDouble $value]
	    my ret [my extract $d 0]
	label yes:
	    my ret [Const true bool]
	}

	    my condBr [my Call tcl.impl.strempty $value] $yes $checkInt
	label checkInt:
	    set i [my GetWide $value]
	    my ret [my extract $i 0]
	label yes:
	    my ret [Const true bool]
	}

	##### Function tcl.isZeroOneBoolean #####
	#
	# Type signature: value:STRING -> ZEROONE
	#
	# Tests if a STRING can be parsed as a ZEROONE BOOLEAN. Part of the
	# implementation of quadcode "instanceOf"

	set f [$m local "tcl.isZeroOneBoolean" ZEROONE<-STRING,ZEROONE]
	params value emptyOK
	build {
	    nonnull $value
	    my br $checkInt
	label checkInt:
	    my condBr [my isInteger $value] $checkZeroOne $checkEmptyOK
	label checkZeroOne:
	    set gw [my GetWide $value]
	    my condBr [my extract $gw 0] $testZeroOne $no
        label testZeroOne:
	    set val [my extract $gw 1]
	    my switch $val $no 0 $yes 1 $yes
	label checkEmptyOK:
	    my condBr $emptyOK $checkEmpty $tryGetBoolean
	label checkEmpty:
	    my condBr [my Call tcl.impl.strempty $value] $yes $tryGetBoolean
	label tryGetBoolean:
	    set i [my GetBoolean $value]
	    my condBr [my extract $i 0] $yes $tryGetInt
	label tryGetInt:
	    set i [my GetWide $value]
	    my condBr [my extract $i 0] $no $checkZeroOne
	label yes:
	    my ret [Const true bool]
	label no:
	    my ret [Const false bool]
	}

	##### Function tcl.extractNumeric #####
	#
	# Type signature: value:STRING -> NUMERIC
	#
	# Parse a STRING as a NUMERIC; the value is known to be parseable.
	# Part of the implementation of quadcode "narrowToType".

	label returnDouble:
	    my ret [my packNumericDouble [my extract $d 1]]
	label extractInt:
	    set i [my GetWide $value]
	    my ret [my packNumericInt [my packInt64 [my extract $i 1]]]
	}

	##### Function: tcl.extractNumericOrBoolean #####
	#
	# Type signature: value:STRING -> NUMERIC BOOLEAN
	#
	# Parse a STRING as a NUMERIC or Boolean; the value is known to
	# be parsable. Part of the implementation of quadcode 'narrowToType'.

	set f [$m local "tcl.extractNumericOrBoolean" "NUMERIC BOOLEAN<-STRING"]
	params value
	build {
	    nonnull $value
	    my br $testType
	label testType:
	    set type [my dereference $value 0 Tcl_Obj.typePtr]
	    my condBr [my nonnull $type] $testIsInt $testIsBoolean
        label testIsInt:
	    my condBr [my isInteger $value] $returnInt $testIsDouble
	label returnInt:
	    set i [my GetWide $value]
	    my ret [my packNumericOrBooleanInt [my packInt64 [my extract $i 1]]]
	label testIsDouble:
	    my condBr [my isDouble $value] $returnDouble $testIsBoolean
	label returnDouble:
	    set d [my GetDouble $value]
	    my ret [my packNumericOrBooleanDouble [my extract $d 1]]
	label testIsBoolean:
	    set b [my GetBoolean $value]
	    my condBr [my extract $b 0] $returnBoolean $getDouble
	label returnBoolean:
	    my ret [my packNumericOrBooleanBoolean [my extract $b 1]]
	label getDouble:
	    set i [my GetDouble $value]
	    my br $testType
	}
			
	##### Function tcl.extractDouble #####
	#
	# Type signature: value:STRING -> DOUBLE
	#
	# Parse a STRING as a DOUBLE; the value is known to be parseable.
	# Part of the implementation of quadcode "narrowToType".

	set f [$m local "tcl.extractInteger" INT<-STRING]
	params value
	build {
	    nonnull $value
	    my ret [my packInt64 [my extract [my GetWide $value] 1]]
	}

	##### Function: tcl.isTrue.numeric #####
	#
	# Type signature: value:STRING->ZEROONE
	#
	# Determines whether a given NUMERIC value represents a value
	# that will cause 'jumpTrue' to jump. Part of the implementation
	# of quadcodes 'jumpTrue' and 'jumpFalse'

	set f [$m local "tcl.isTrue.numeric" ZEROONE<-NUMERIC]
	params value
	build {
	    my condBr [my isNumericInt $value] $doInteger $doDouble
	label doInteger:
	    my ret [my neq(INT,INT) [my numeric.int $value] [my int 0]]
	label doDouble:
	    my ret [my neq(DOUBLE,DOUBLE) \
			[my numericOrBoolean.double $value] [Const 0.0 double]]
	}

	##### Function: tcl.isTrue.numericOrBoolean #####
	#
	# Type signature: value:STRING->ZEROONE
	#
	# Determines whether a given NUMERIC BOOLEAN value represents a value
	# that will cause 'jumpTrue' to jump. Part of the implementation
	# of quadcodes 'jumpTrue' and 'jumpFalse'

	set f [$m local "tcl.isTrue.numericOrBoolean" \
		   {ZEROONE<-NUMERIC BOOLEAN}]
	params value
	build {
	    my switch [my getNumericBooleanKind $value] \
		$doBoolean 0 $doInteger 1 $doDouble
	label doBoolean:
	    my ret [my numericOrBoolean.bool $value]
	label doInteger:
	    my ret [my neq(INT,INT) [my numericOrBoolean.int $value] [my int 0]]
	label doDouble:
	    my ret [my neq(DOUBLE,DOUBLE) \
			[my numericOrBoolean.double $value] [Const 0.0 double]]
	}
	
	##### Function tcl.cmp.strstr #####
	#
	# Type signature: value1Ptr:STRING * value2Ptr:STRING -> int
	#
	# Returns the relationship between the two string arguments where
	# numeric comparisons are preferred; -1 if 'value1Ptr' precedes in
	# standard ordering, 1 if 'value2Ptr' precedes, and 0 if they are

	label decr "action.required"
	    set value [my unmaybe $value "objPtr"]
	    $api Tcl_DecrRefCount $value
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}

	##### tcl.maybeAddReference #####
	#
	# Type signature: maybe:bool,objPtr:Tcl_Obj* -> void
	#
	# Increment the reference count of a Tcl_Obj if the
	# object exists.

	set f [$m local "tcl.maybeAddReference" void<-bool,Tcl_Obj*]
	params maybe value
	build {
	    my condBr $maybe $nothing $incr
	label incr "action.required"
	    $api Tcl_IncrRefCount $value
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}
	my closure impure.maybeAddReference {maybe value} {
	    my call ${tcl.maybeAddReference} [list $maybe $value]
	}

	##### tcl.maybeDropReference #####
	#
	# Type signature: maybe:bool,objPtr:Tcl_Obj* -> void
	#
	# Decrement the reference count of a Tcl_Obj if the
	# object exists.

	set f [$m local "tcl.maybeDropReference" void<-bool,Tcl_Obj*]
	params maybe value
	build {
	    my condBr $maybe $nothing $decr
	label decr "action.required"
	    $api Tcl_DecrRefCount $value
	    my ret
	label nothing "nothing.to.do"
	    my ret
	}
	my closure impure.maybeDropReference {maybe value} {
	    my call ${tcl.maybeDropReference} [list $maybe $value]
	}

	##### tcl.addNExistReference #####
	#
	# Type signature: objPtr:Tcl_Obj*! -> void
	#
	# Increment the reference count of a Tcl_Obj reference if the
	# object is supplied

	    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 -> int1*int1

	set f [$m local "tcl.impl.getBoolean" struct{int1,int1}<-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{int1,int1}]
	    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

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

	set f [$m local "tcl.booleanTest" ZEROONE<-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]
	}
	

	##### Function tcl.invoke.command #####
	#
	# Type signature: objc:int * objv:STRING* * ecvar:int* -> STRING?
	#
	# Calls the Tcl interpreter to invoke a Tcl command, and packs the
	# result into a STRING FAIL.

    #
    # Results:
    #	None.

    method InitTclTypes {} {
	# WARNING: int type may need to be larger on some platforms!
	Type NUMERIC; # Make sure we get this early, just in case
	Type "NUMERIC BOOLEAN"

	# Debug-world delegates for the basic types
	DBTY void <- void   void "void"
	DBTY ptr  <- ClientData  pointer "ClientData" $void
	DBTY chr  <- char   int "char" 8
	DBTY chrs <- char*  pointer "char*" $chr
	DBTY i16  <- int16  int "Tcl_UniChar" 16

	    i32:int32
	    i64:int64
	}
	struct NUMERIC {
	    kind:bool
	    int:INT
	    double:double
	}
	struct NUMERIC_BOOLEAN {
	    kind:int3
	    int:INT
	    double:double
	    bool:bool
	}
	struct FOREACH {
	    val:int
	    max:int
	}
	struct DICTFOR {
	    search:DictSearch

	foreach {ty rt1} {
	    i32      int32
	    i64      int64
	    ZON      ZEROONE
	    INT      INT
	    DBL      DOUBLE
	    NUMERIC  NUMERIC
	    NUMERIC_BOOLEAN "NUMERIC BOOLEAN"
	    STR      STRING
	    ARY      ARRAY
	    ASTR     ARRAYSTRING
	} {
	    upvar 0 $ty t
	    set rt [linsert $rt1 0 IMPURE]
	    DBTY impure <- $rt struct <$rt1> $Obj $t

	    }
	    {INT DOUBLE} {
		append body2 { [my cast(DOUBLE) $} [lindex $f 0] { cast]}
	    }
	    {{INT BOOLEAN} NUMERIC} {
		append body2 { [my packNumericInt $} [lindex $f 0] { cast]}
	    }
	    {{INT BOOLEAN} {NUMERIC BOOLEAN}} {
		append body2 { [my packNumericOrBooleanInt $} [lindex $f 0] { cast]}
	    }
	    {ZEROONE NUMERIC} {
		append body2 { [my packNumericInt [my cast(BOOLEAN) $} [lindex $f 0] { cast]]}
	    }
	    {ZEROONE {NUMERIC BOOLEAN}} {
		append body2 { [my packNumericOrBooleanInt $} [lindex $f 0] { cast]}
	    }
	    {INT NUMERIC} {
		append body2 { [my packNumericInt $} [lindex $f 0] { cast]}
	    }
	    {INT {NUMERIC BOOLEAN}} {
		append body2 { [my packNumericOrBooleanInt $} [lindex $f 0] { cast]}
	    }
	    {DOUBLE NUMERIC} {
		append body2 { [my packNumericDouble $} [lindex $f 0] { cast]}
	    }
	    {DOUBLE {NUMERIC BOOLEAN}} {
		append body2 { [my packNumericOrBooleanDouble $} [lindex $f 0] { cast]}
	    }
	    {BOOLEAN {NUMERIC BOOLEAN}} {
		append body2 { [my packNumericOrBooleanBoolean $} [lindex $f 0] { cast]}
	    }

	    {{ZEROONE BOOLEAN} ZEROONE} {
		append body2 { $} [lindex $f 0]
	    }
	    {{ZEROONE BOOLEAN} STRING} {
		set var [lindex $f 0]
		append body1 ";" [string trim [subst -nocommands {
		    lappend {string casts} [set $var [my {stringify($t)} $$var]]

		set var [lindex $f 0]
		append body1 ";" [string trim [subst -nocommands {
		    lappend {string casts} [set $var [my {stringify($t)} $$var]]
		    my addReference(STRING) $$var
		}]]
		append body2 { $} [lindex $f 0]
	    }
	    {{NUMERIC BOOLEAN} STRING} {
		set var [lindex $f 0]
		append body1 ";" [string trim [subst -nocommands {
		    lappend {string casts} [set $var [my {stringify($t)} $$var]]
		    my addReference(STRING) $$var
		}]]
		append body2 { $} [lindex $f 0]
	    }
	    {EMPTY STRING} {
		append body2 { $} [lindex $f 0]
	    }
	    {{IMPURE ZEROONE} {IMPURE INT}} {
		append body2 [format { [my upcastImpure.INT(ZEROONE) $%s]} [lindex $f 0]]
	    }
	    {{IMPURE ZEROONE} {IMPURE NUMERIC}} {
		append body2 [format { [my upcastImpure.NUMERIC(ZEROONE) $%s]} [lindex $f 0]]
	    }
	    {{IMPURE INT} {IMPURE NUMERIC}} {
		append body2 [format { [my upcastImpure.NUMERIC(INT) $%s]} [lindex $f 0]]
	    }
	    {{IMPURE DOUBLE} {IMPURE NUMERIC}} {
		append body2 [format { [my upcastImpure.NUMERIC(DOUBLE) $%s]} [lindex $f 0]]
	    }
	    {{IMPURE ZEROONE} {IMPURE {NUMERIC BOOLEAN}}} {
		append body2 [format { [my upcastImpure.NUMERIC\040BOOLEAN(ZEROONE) $%s]} [lindex $f 0]]
	    }
	    {{IMPURE INT} {IMPURE NUMERIC}} {
		append body2 [format { [my upcastImpure.NUMERIC\040BOOLEAN(INT) $%s]} [lindex $f 0]]
	    }
	    {{IMPURE DOUBLE} {IMPURE NUMERIC}} {
		append body2 [format { [my upcastImpure.NUMERIC\040BOOLEAN(DOUBLE) $%s]} [lindex $f 0]]
	    }
	    {{IMPURE BOOLEAN} {IMPURE NUMERIC}} {
		append body2 [format { [my upcastImpure.NUMERIC\040BOOLEAN(BOOLEAN) $%s]} [lindex $f 0]]
	    }
	    {NOTHING STRING} {
		append body2 { [my undef STRING]}
	    }
	    {{EXPANDED STRING} 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]
	    }
	}

	foreach type {
	    BOOLEAN
	    ZEROONE {ZEROONE BOOLEAN}
	    INT {INT BOOLEAN}
	    DOUBLE
	    NUMERIC
	    {NUMERIC BOOLEAN}
	} {
	    set impureType [linsert $type 0 IMPURE]

	    dict set TypeConversions [list $type $impureType] [string trim \
		    [string map [list @type $type] {
			set var [lindex $f 0]
			append body2 { [my {packImpure(@type)} $} $var {]}

    #	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} {
	if {[regexp {^addReference\(FAIL[ _]IMPURE (.*)\)$} \
		 $methodName -> utype]} {
	    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
	} elseif {[regexp {^dropReference\(FAIL[ _]IMPURE[ _](.*)\)$} \
		       $methodName -> utype]} {
	    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
	} elseif {[regexp {^addReference\(IMPURE[ _](.*)\)$} \
		       $methodName -> utype]} {
	    oo::objdefine [self] method $methodName {value} \
		[string map [list @utype $utype] {
		    my addReference(STRING) [my impure.string $value]



		}]
	    tailcall my $methodName {*}$args

	} elseif {[regexp {^dropReference\(IMPURE[ _](.*)\)$} $methodName \
		       -> utype]} {
	    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?)

	# Special "constants"
	my buildInSection APIvar {
	    my APIVar tclIntType \
		[set it [my Tcl_GetObjType [$b constString "int" "type.int"]]]
	    my APIVar tclDoubleType \
		[my Tcl_GetObjType [$b constString "double" "type.double"]]
	    my APIVar tclBooleanType \
		[my Tcl_GetObjType [$b constString "booleanString" type.boolean"]]
	    my APIVar tclByteArrayType \
		[my Tcl_GetObjType [$b constString "bytearray" "type.bytes"]]
	    my APIVar tclStringType \
		[my Tcl_GetObjType [$b constString "string" "type.string"]]
	    set wt [my Tcl_GetObjType [$b constString "wideInt" "type.wide"]]
	    my APIVar tclWideIntType [$b select [$b nonnull $wt] $wt $it]
	    my APIVar tclListType \

    # The actual flag values to use in the INT type
    variable INT.type.32bit 0
    variable INT.type.64bit 1

    # The actual flag values to use in the NUMERIC type
    variable NUMERIC.type.int 0
    variable NUMERIC.type.double 1

    # The actual flag values to use in the NUMERIC_BOOLEAN type
    variable NUMERIC_BOOLEAN.type.int 0
    variable NUMERIC_BOOLEAN.type.double 1
    variable NUMERIC_BOOLEAN.type.bool 2

    # Named structure types need to be only created once
    variable NamedTypeCache {}
    variable NamedTypeCacheAhead {}

    # LLVM::Const --
    #

	    }
	    "^EXPANDED (.*)$" {
		return [Type [lindex $m 1]]
	    }
	    ^NUMERIC$ {
		return [Type named{NUMERIC,kind:int1,int:INT,double:DOUBLE}]
	    }
	    "^NUMERIC BOOLEAN$" {
		return [Type named{NUMERIC_BOOLEAN,kind:int3,int:INT,double:DOUBLE,bool:bool}]
	    }
	    ^FOREACH$ {
		return [Type named{FOREACH,val:int,max:int}]
	    }
	    ^DICTITER$ {
		return [Type "named{DICTFOR,
			search:DictSearch,
			dict:STRING,

    return $result
}

proc concatenater {x} {
    set x [expr {int($x)}]
    concat [expr {$x - 1}] $x [expr {$x + 1.5}] "ok"
}

proc nottest {val} {
    expr {!$val}
}

proc iftest {val} {
    if {$val} {return yes} {return no}
}

proc landtest {val} {
    expr {$val && $val}

    # Tcl 8.7 does not generate INST_LAND except when the bytecode assembler
    # requests it. If we wanted to test INST_LAND, we'd need a sequence like
    #
    #    tcl::unsupported::assemble {
    #	     load val
    #	     load val
    #	     land
    #    }
}

proc lortest {val} {
    expr {$val || $val}

    # Tcl 8.7 does not generate INST_LOR except when the bytecode assembler
    # requests it. If we wanted to test INST_LOR, we'd need a sequence like
    #
    #    tcl::unsupported::assemble {
    #	     load val
    #	     load val
    #	     lor
    #    }
    #
    # But that's not implemented in the code generator, and there's no
    # really good reason to implement it, since Tcl doesn't use it.
}

proc booltest {val} {
    set res {}
    if {[string is boolean -strict $val]} {
	lappend res ok
    }
    lappend res [string is boolean $val]

    {cmptest2 0e0 0x0}
    {trimtest ABCDABC}
    {trimtest DABCABCD}
    {casetest aBcDe}
    {strclasstest abc123}
    {strclasstest abc-123}
    {concatenater 7}
    {nottest 1}
    {nottest 0}
    {nottest 2.0}
    {nottest true}
    {list [catch {nottest fruitbat} stat] $stat}
    {iftest yes}
    {iftest no}
    {iftest 1}
    {iftest 0}
    {iftest 0.0}
    {iftest 2.0}
    {list [catch {iftest fruitbat} stat] $stat}
    {landtest yes}
    {landtest no}
    {landtest 1}
    {landtest 0}
    {landtest 2.0}
    {landtest 0.0}
    {list [catch {landtest fruitbat} stat] $stat}
    {lortest yes}
    {lortest no}
    {lortest 1}
    {lortest 0}
    {lortest 2.0}
    {lortest 0.0}
    {list [catch {lortest fruitbat} stat] $stat}
    {list [booltest on] [booltest no] [booltest ""] [booltest fruitbat]}
    {stristest ""}
    {stristest x}
    {stristest 0}
    {stristest 1.2}
    {stristest 0xAB}
    # List operations (also see some [try] tests)

    cmptest
    cmptest2
    matchtest
    replacing replacing2 replacing3
    strclasstest
    jumptable
    concatenater
    nottest
    iftest
    landtest
    lortest
    booltest
    stristest
    regsubtest
    # Failure handling, [subst], [try]
    wideretest
    substtest
    substtest2

}

# quadcode::bytecodeAbbreviator1 --
#
#	Singleton instance of the bytecode abbreviator.

quadcode::bytecodeAbbreviator create quadcode::bytecodeAbbreviator1 {

    stringIsBooleanStrict {
	tryCvtToBoolean
	reverse 2
	pop
    }

    stringIsIntStrict {
	numericType
	dup
	jumpFalse1 +5
	push1 {literal 1}
	eq

    }

    stringIsDoubleStrict {
	numericType
	jumpTrue1 +6
	push1 {literal 0}
	jump1 +4
	push1 {literal 1}
    }

    stringIsBoolean {
	tryCvtToBoolean
	jumpTrue1 +7
	push {literal {}}
	streq
	jump1 +5
	pop
	push1 {literal 1}
    }

    stringIsInt {
	dup
	numericType
	dup

	    reverse -
	    storeScalar1 -
	    storeScalar4 -
	    strcaseLower -
	    strcaseTitle -
	    strcaseUpper -
	    strclass -
	    stringIsBoolean -
	    stringIsBooleanStrict -
	    stringIsDouble -
	    stringIsDoubleStrict -
	    stringIsEntier -
	    stringIsEntierStrict -
	    stringIsInt -
	    stringIsIntStrict -
	    stringIsWide -

    }

    my debug-specializer {
	puts "REGISTER: $procName"
    }

    set s [catch {

	# Convert the procedure to quadcode and perform the initial
	# quadcode-to-quadcode transformations. Add the quadcode database to
	# the 'database' dictionary.
	set ns [namespace qualifiers $origin]
	set bytecode [tcl::unsupported::getbytecode proc $origin]
	set db [quadcode::transformer new \
		    -origin $origin \

    }

    # Find places to insert phi nodes

    set phis [lrepeat [llength $bbcontent] {}]
    dict for {v -} $global {
	if {[dict exists $writers $v]} {
	    if {[dict exists $writers $v]} {
		set w [dict keys [dict get $writers $v]]
	    } else {
		set w {}
	    }
	    foreach n [my bbfrontier+ $w] {
		set list [lindex $phis $n]
		lset phis $n {}
		lappend list [list phi $v]
		lset phis $n $list
	    }
	}
    }

		set v1 [list temp [incr depth -1]]
		set v0 [list temp [incr depth -1]]
		set r $v0
		my quads [lindex $insn 0] $r $v0 $v1
	    }
	    uplus -
	    uminus -
	    not -
	    bitnot {		# Unary ops
		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}

	    jumpFalse1 -
	    jumpFalse4 {	# Conditional jump
		incr depth -1
		switch -exact -- [lindex $insn 1 0] {
		    pc {
			set to_pc [lindex $insn 1 1]
			set to_test [list temp $depth]
			my generate-arith-domain-check $to_pc jumpFalse $to_test
			my generate-jump $to_pc false $to_test
		    }
		    default {
			return -code error "I don't know what to do with\
                               [lindex $insn 1 0] as a jump target."
		    }
		}
	    }
	    jumpTrue1 -
	    jumpTrue4 {		# Conditional jump
		incr depth -1
		switch -exact -- [lindex $insn 1 0] {
		    pc {
			set to_pc [lindex $insn 1 1]
			set to_test [list temp $depth]
			my generate-arith-domain-check $pc jumpTrue $to_test
			my generate-jump $to_pc true $to_test
		    }
		    default {
			return -code error "I don't know what to do with\
                               [lindex $insn 1 0] as a jump target."
		    }
		}

		my quads [lindex $insn 0] $r $v0
	    }
	    originCmd {
		set v0 [list temp [incr depth -1]]
		set r $v0
		my error-quads $pc [lindex $insn 0] $r $v0
	    }
	    stringIsBoolean -
	    stringIsBooleanStrict -
	    stringIsDouble -
	    stringIsDoubleStrict -
	    stringIsEntier -
	    stringIsEntierStrict -
	    stringIsInt -
	    stringIsIntStrict -
	    stringIsWide -
	    stringIsWideStrict {
		regexp -expanded {
		    ^
		    stringIs(Boolean|Double|Entier|Int|Wide)
		    ((?:Strict)?)
		    $
		} [lindex $insn 0] -> type strict
		switch -exact $type {
		    Boolean {
			set typecode $quadcode::dataType::BOOLEAN
		    }
		    Double {
			set typecode $::quadcode::dataType::NUMERIC
		    }
		    Entier {
			set typecode $::quadcode::dataType::ENTIER
		    }
		    Wide {

	     bitand [list &  INT] \
	     bitor  [list |  INT] \
	     bitxor [list ^  INT] \
	     mod    [list %  INT] \
	     lshift [list << INT] \
	     rshift [list << INT] \
	     bitnot [list ~  INT] \
	     jumpTrue [list "boolean test" NUMERIC_OR_BOOLEAN] \
	     jumpFalse [list "boolean test" NUMERIC_OR_BOOLEAN] \
	     land [list "&&" NUMERIC_OR_BOOLEAN] \
	     lor [list "||" NUMERIC_OR_BOOLEAN] \
	     not [list "!" NUMERIC_OR_BOOLEAN] \
	     infoLevelArgs [list "info level" INT]]
}
oo::define quadcode::transformer method \
    generate-arith-domain-check {pc operator args} {
	namespace upvar ::quadcode operator_info operator_info
	set target [my exception-target $pc catch]
	if {![dict exists $operator_info $operator]} return

    # NUMERIC - the value is a number of some sort.
    #              A constant $x of this type will be pure iff either
    #              {entier($x) eq $x} or {double($x) eq $x} - that is,
    #              it is a number in canonical form.

    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}]

    # 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]

#
# Results:
#	Returns the deduced data type of q's left hand side

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
    }

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

	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 - listIn {
	    return [expr {$ZEROONE | $FAIL}]
	}
	listLength - dictSize {
	    return [expr {$INT | $FAIL}]
	}
	phi {
	    set r 0
	    foreach {from operand} [lrange $q 2 end] {