Implementing post / pre increment / decrement when translating to Lua

Question

I'm writing a LSL to Lua translator, and I'm having all sorts of trouble implementing incrementing and decrementing operators. LSL has such things using the usual C like syntax (x++, x--, ++x, --x), but Lua does not. Just to avoid massive amounts of typing, I refer to these sorts of operators as "crements". In the below code, I'll use "..." to represent other parts of the expression.

... x += 1 ...

Wont work, coz Lua only has simple assignment.

... x = x + 1 ...

Wont work coz that's a statement, and Lua can't use statements in expressions. LSL can use crements in expressions.

function preIncrement(x)  x = x + 1;  return x;  end
... preIncrement(x) ...

While it does provide the correct value in the expression, Lua is pass by value for numbers, so the original variable is not changed. If I could get this to actually change the variable, then all is good. Messing with the environment might not be such a good idea, dunno what scope x is. I think I'll investigate that next. The translator could output scope details.

Assuming the above function exists -

... x = preIncrement(x) ...

Wont work for the "it's a statement" reason.

Other solutions start to get really messy.

x = preIncrement(x)
... x ...

Works fine, except when the original LSL code is something like this -

while (doOneThing(x++))
{
  doOtherThing(x);
}

Which becomes a whole can of worms. Using tables in the function -

function preIncrement(x)  x[1] = x[1] + 1;  return x[1];  end
temp = {x}
... preincrement(temp) ...
x = temp[1]

Is even messier, and has the same problems.

Starting to look like I might have to actually analyse the surrounding code instead of just doing simple translations to sort out what the correct way to implement any given crement will be. Anybody got any simple ideas?

Answer 1

After some research and thinking I've come up with an idea that might work.

For globals -

function preIncrement(x)
  _G[x] = _G[x] + 1
  return _G[x]
end
... preIncrement("x") ...

For locals and function parameters (which are locals to) I know at the time I'm parsing the crement that it is local, I can store four flags to tell me which of the four crements is being used in the variables AST structure. Then when it comes time to output the variables definition, I can output something like this -

local x;
function preIncrement_x() x = x + 1;  return x;  end
function postDecrement_x() local y = x;  x = x - 1;  return y;  end
... preIncrement_x() ...