Tcl Source Code

View Ticket
Login
Ticket UUID: 2859027
Title: Bytecode Compiler & tcl_precision
Type: Bug Created on: 2009-09-15 02:15:22
Submitter: pixelz Assigned to: dgp
Subsystem: 47. Bytecode Compiler Severity:
Priority: 2 Last modified: 2009-09-16 02:35:25
Status: Open Closed by:
Resolution: None Closed on:
Version: obsolete: 8.5.7
Description:
The bytecode compiler breaks on the following snippet:

proc DoPrecision {} { puts "A $::tcl_precision [expr { 1.1 + 2.2 }]"
if {[catch { incr ::tcl_precision }]} { return }
puts "B $::tcl_precision [expr { 1.1 + 2.2 }]"
DoPrecision
}
DoPrecision

Example result:
A 0 3.3000000000000003
B 1 3.0
A 1 3.3000000000000003
B 2 3.0
A 2 3.3000000000000003
B 3 3.0
A 3 3.3000000000000003
B 4 3.0
A 4 3.3000000000000003
B 5 3.0
A 5 3.3000000000000003
B 6 3.0
A 6 3.3000000000000003
B 7 3.0
A 7 3.3000000000000003
B 8 3.0
A 8 3.3000000000000003
B 9 3.0
A 9 3.3000000000000003
B 10 3.0
A 10 3.3000000000000003
B 11 3.0
A 11 3.3000000000000003
B 12 3.0
A 12 3.3000000000000003
B 13 3.0
A 13 3.3000000000000003
B 14 3.0
A 14 3.3000000000000003
B 15 3.0
A 15 3.3000000000000003
B 16 3.0
A 16 3.3000000000000003
B 17 3.0
A 17 3.3000000000000003
User Comments:
dgp added on 2009-09-16 00:34:49:
Starting in Tcl 8.5, the expression parser
detects constant expressions such as
" 1.1 + 2.2 " and notices that their value
is completely known at compile time, and
creates bytecode that simply pushes  that
value on the stack.  There is no runtime
computation at all.

This makes perfect sense using the 8.5
defaults where EIAS for double values
actually works.

For legacy support of scripts continuing
to use the ::tcl_precision variable against
advice, the assumption that a constant
expression will always compute the same
result fails.

Perhaps this can be fixed with some additional
detections of changes to the ::tcl_precision
variable triggering a reset of some compile epoch
to force recompile of the expressions?

dgp added on 2009-09-16 00:38:02:
A workaround would be to store the
constant values "1.1" and "2.2" in
variables so that compiling the expression
does not introduce the optimization.

set x 1.1; set y 2.2;
expr {$x + $y}

dgp added on 2009-09-16 02:26:21:
It appears this could be accommodated with
changes to Tcl_PrintDouble() and TclPrecTraceProc(),
but it is not clear at what expense.  Keeping this
open at a low priority.  Recommend either the
workaround already noted, or some other means
to attack whatever real problem is trying to be
addressed with the ::tcl_precision games.

pixelz added on 2009-09-16 02:32:59:
tcl_precision doesn't have to be touched for this unexpected result to happen, simply:

% expr 1.1+2.2
3.3000000000000003

in a fresh tclsh

hobbs added on 2009-09-16 02:35:25:
And that result is technically correct in IEEE math, which is what Tcl is exposing.