# Results:
    #	An IMPURE BOOLEAN LLVM value reference.

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

    #	An IMPURE NUMERIC LLVM value reference.

    method narrowToType.IMPURE_NUMERIC(STRING) {value {name ""}} {
	set nval [my call ${tcl.extractNumeric} [list $value]]
	my addReference(STRING) $value
	return [my impure NUMERIC $value $nval $name]
    }

    # Builder:narrowToType.IMPURE_ZEROONE_BOOLEAN(STRING) --
    #
    #	Generate code to parse the given STRING and extract a Boolean value,
    #	either the integer 0 or 1 or one of the Boolean words. The STRING
    #	is already known to contain a value of the right type. Quadcode
    #	implementation ('narrowToType')
    #
    # Parameters:
    #	value - The STRING LLVM reference to parse.
    #   name (optional) - A name to give to the result value.

    method narrowToType.IMPURE_ZEROONE_BOOLEAN(STRING) {value {name ""}} {
	set bval [my call ${tcl.extractZeroOneBoolean} [list $value]]
	my addReference(STRING) $value
	return [my impure {ZEROONE BOOLEAN} $value $bval $name]
    }

    # Builder:nothing --
    #
    #	Create a Nothing NEXIST of the given type.
    #
    # Parameters:
    #	type -	The type of the NEXIST.

    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.numeric tcl.isTrue.numericOrBoolean
    variable tcl.isZeroOneBoolean
    variable tcl.extractNumeric tcl.extractNumericOrBoolean
    variable tcl.extractDouble tcl.extractInteger
    variable tcl.extractZeroOneBoolean
    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

	    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.extractZeroOneBoolean #####
	#
	# Type signature: value:STRING -> ZEROONE
	#
	# Parse a STRING as a Boolean value. The value is known to be
	# parsable.  Part of the implementation of quadcode 'narrowToType'.

	set f [$m local "tcl.extractZeroOneBoolean" "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 $testIsBoolean
	label returnInt:
	    set gw [my GetWide $value]
	    set i [my extract $gw 1]
	    my switch $i $no 0 $yes
	label no:
	    my ret [Const true bool]
	label yes:
	    my ret [Const false bool]
	label testIsBoolean:
	    set b [my GetBoolean $value]
	    my condBr [my extract $b 0] $returnBoolean $testIsInt
	label returnBoolean:
	    my ret [my extract $b 1]
	}
			
	##### 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".

    regsubtest
    # Failure handling, [subst], [try]
    wideretest
    substtest
    substtest2
    switchfail
    trimtest
    # magicreturn TEMP - skip this, it doesn't compile
    returntest
    errortest1
    errortest2
    errortest2-caller
    errortest3
    errortest4 errortest4a errortest4b
    errortest5 errortest6

    rangetest
    numberitems numberitems2 numberitems3 doubleitems
    containment
    lsorttest
    lsortcmd
    # Dictionary operations (also see some [try] tests)
    dictest
    dictest2
    # dictest3			TEMP generates incorrect code
    dictest4 dictest5
    # dictest6 dictest7		TEMP generates incorrect code
    # dictest8			TEMP generates incorrect code
    dictest9

    dictfor
    # Nonexistent variables
    nextest1
    nextest2
    nextest3
    nextest4
    # Array operations
    arrayTest::*
    wordcounter1
    wordcounter2
    wordcounter3
    wordcounter4
    # Calls of uncompiled code
    calltest
    calltest2
    calltest3
    # Callframe tests
#    callframe::test1		TEMP direct ops
#    callframe::test2		TEMP direct ops
#    callframe::test3		TEMP direct ops
#    callframe::test4		TEMP direct ops
    # The interprocedural tests
    mrtest::*
    coscaller1
    coscaller2
    xsum xsum2
    # Namespace tests
    # nstestaux::pts	depends on direct ops
    nstest::nstest0
    nstest::nstest1
    # nstest::nstest2   fails with command not found
    nstest::nstest3
    nstest::nstest4
    # nstest::nstest5   fails with invalid command name
    nstest::nstest6

	    ge gt
	    initIfNotExists
	    instanceOf
	    le
	    listAppend listConcat listIn listIndex listLength listRange
	    listSet
	    lshift lt
	    maptoint mod mult
	    narrowToType neq not
	    purify
	    regexp retrieveResult rshift
	    strcase strcat strclass strcmp streq strfind strindex strlen
	    strmap strmatch strrange strreplace strrfind strtrim
	    sub
	    uminus