proc impure {a b c} {
    set x 0
    for {set i $a} {$i < $b} {incr i $c} {
	set x [expr {$x + $i}]
    }
    return $x
}

proc wideimpure {x} {
    expr {wide($x)}
}

proc impure-typecheck-int {a b c} {
    if {[string is int -strict $a]
	&& [string is int -strict $b]
	&& [string is int -strict $c]} {
	set x 0
	for {set i $a} {$i < $b} {incr i $c} {

    upvartest0::check2
    upvartest1::check1
    upvartest1::check2
    upvartest2::test1
    upvartest2::test2
    upvartest2::test3
    upvartest2::test4
    {wideimpure 3.0}

    {hash::H9fast ultraantidisestablishmentarianistically}
    {hash::H9mid ultraantidisestablishmentarianistically}
    {hash::H9slow ultraantidisestablishmentarianistically}

    {toHex [poly1305 compute $key $msg]}
    {poly1305 verify $key $msg $tag}

    upvar0
    upvar0a
    upvartest0::*
    upvartest1::*
    upvartest2::*
    flightawarebench::*
    hash::*
    wideimpure
    poly1305::*
    poly1305::tcl::mathfunc::*
}
set toCompile'slow' {
    parseBuiltinsTxt::main
}


# generate-function-param-check --
#
#	Generates a check to make sure that a value conforms with a function's
#	requirement for its parameter type. Do not call from anywhere but
#	bytecode-to-quads!
#
# Parameters:
#	q - A list comprising the function name and arguments expressed as
#           quadcode values.
#
# Results:
#	None.
#
# Side effects:
#	Inserts a parameter type checking sequence.
#

	# 2
	my quads [list initParamTypeException $i] {temp @exception} \
	    $val $functionName
	# 3
	my quads extractFail {temp @exception} {temp @exception}
	# 4
	my generate-jump $target
	# 5 - ok:
        my quads [list purifyParam $i] $val $val $functionName
	# 6
	# (next instruction)
	
    }
}

# quads --
#

			lset bbcontent $b $j \
			    [list initException $result $msgLit $exn \
				 {literal 1} {literal 0}]
			incr j
		    } else {
			my removeUse $src $b
			my replaceUses $result Nothing
			# delete the quad
		    }

		}

		"instanceOfParamType" {
		    lassign $q op result src fref
		    set t [my determineFunctionParamType $op $fref]
		    if {$t != $quadcode::dataType::STRING} {
			set t [expr {$t | $quadcode::dataType::IMPURE}]
			set op [list "instanceOf" $t [nameOfType $t]]
			lset bbcontent $b $j [list $op $result $src]
			incr j
		    } else {
			my removeUse $src $b
			my replaceUses $result {literal 1}
			# delete the quad
		    }
		}

		"purifyParam" {
		    lassign $q op result src fref
		    set t [my determineFunctionParamType $op $fref]
		    if {$t != $quadcode::dataType::STRING} {
			lset bbcontent $b $j [list purify $result $src]
			incr j
		    } else {
			my removeUse $src $b
			my replaceUses $result $src
			# delete the quad
		    }
		}

		default {
		    lset bbcontent $b $j $q
		    incr j
		}

	}
	copy {
	    return [typeOfOperand $types [lindex $q 2]]
	}
	purify {
	    return [expr {[typeOfOperand $types [lindex $q 2]] & ~$IMPURE}]
	}
	purifyParam {
	    # Will be replaced with 'purify' when type is known, but must
	    # be at most a subset of the type of the source operand
	    return [typeOfOperand $types [lindex $q 2]]
	}
	unset {
	    return $NEXIST
	}
	setReturnCode {
	    return $FAIL
	}
	initException {

   1 or 0 according to the result.
{{instanceOfParamType N} TGT SRC CMD}
   Sets TGT to 1 or 0 depending on whether the type of SRC is appropriate
   as parameter #N to the command CMD
{{initParamTypeException N} TGT SRC CMD}
   Sets TGT to a FAIL value indicating that SRC is inappropriate for parameter
   #N to the command CMD.
{purify TGT SRC}
   Sets TGT to SRC, with any IMPURE indication removed
{{purifyParam N} TGT SRC FUNC}
   Sets TGT to SRC, with any IMPURE indication removed, if FUNC is a built-in
   math function requiring a pure value as argument #N.
   Otherwise, simply sets TGT to SRC. This operation is
   replaced with 'purify' or removed during optimization. It is there to
   purify the operands of built-in mathfuncs.

For these operations, the data types that must be implemented are INT32,
INT, ENTIER, DOUBLE; the same four data types unioned with EMPTY; and the
complements of these eight types, so there are sixteen variants in all.