OpenEuphoria

Re: Major Bug in Interpreter [Attn: Robert Craig]

• Posted by Patrick Barnes <mrtrick at gmail.com> Feb 16, 2005
• 489 views

On Wed, 16 Feb 2005 07:59:27 -0800, Robert Craig
<guest at rapideuphoria.com> wrote:
> I could give a warning, but I think the false-alarm ratio would
> be too high for it to be useful. There would often be
> dozens or maybe hundreds of variables that might potentially
> be overwritten as a result of a function call. It's theoretically
> impossible to always know at compile-time whether a given variable
> will actually be overwritten at run-time. In many cases the
> potential will seem to be there, but in reality it will not happen.

Maybe hundreds? I don't mean a warning when a global variable might be
modified in a function, I mean a warning where in LHS = RHS(), the LHS
contains global variables that might be modified inside the RHS()
function. I think you can agree that this is the case being discussed,
and it's a problem that cannot be simply resolved by the programmer.

Some examples:

integer i
function do_i()
    i = 20
    return i + 1
end function
i = 10
i = do_i()
}}}
<eucode>
In this case, it's no big deal, i will be rewritten by the function
return anyway - no warning: i = 21

}}}
<eucode>
sequence arr
arr = {1,2,3,4,5}
function rem(integer i)
      arr = arr[1..i-1]&arr[i+1..$]
      return arr
end function
arr = rem(3)

Again, not a problem, as arr is rewritten by the function return - no
warning: arr = {1,2,4,5}

sequence arr
arr = {1,2,3,4,5}
function rem(integer i)
      arr = arr[1..i-1]&arr[i+1..$]
      return i*i
end function
arr[3] = rem(3)

This is a problem, as the LHS has to be resolved... does it refer to
arr before rem() is called, or after? WARNING. If after, arr =
{1,2,9,5}. If before, who knows? Maybe i*i is assigned to an element
that is deleted immediately after...

sequence arr
integer ind
arr = {1,2,3,4,5}
ind = 3
function stuff()
      ind = 2
      return 100
end function
arr[ind] = stuff()

This is a problem, as the subscripting variable is changed by the
function... WARNING
If it's resolved before, arr = {1,2,100,4,5}. If after, arr = {1,100,3,4,5}

sequence arr
integer ind
arr = {1,2,3,4,5}
ind = 3
function stuff()
      arr = {5,4,3,2,1}
      ind = 2
      return 100
end function
arr = arr[1..2] & stuff() & arr[ind]

Hmm, can the RHS ever be ambiguous? Maybe a problem, Rob? WARNING?
Assuming that all the elements are resolved before the function: arr =
{1,2, 100, 3}
Assuming that elements are resolved after the function: arr = {5,4, 100, 4}
Assuming that elements are resolved in their order: arr = {1,2, 100, 4}
Very strange stuff, but it could quite easily happen. A similar
example could occur where the LHS is an atom, with mathematical ops on
the RHS rather than concats.
Another example may occur where in a slice operation: arr[var..func()]
, var is modified by func().



Seems to me, that warnings should occur if:
* The left-hand-side is a sequence AND
* The left-hand-side is subscripted by a variable AND
* That variable is modified by the RHS function

Or
* The left-hand-side is a sequence AND
* The left-hand-side is subscripted by a variable or a literal AND
* The array is modified by the RHS function

Or
* An expression consists of both a variable and a function call
(connected together with concat or mathop, etc) AND
* That function call modifies the variable


I don't think there would be many false positives here... Rob, what
'hundreds' are you talking about?

-- 
MrTrick