256 levels of recursion??

[floyduk]

I've just started trying to write some games in flash. It seemed the ideal
language since it's cross platform, ubiquitous and highly functional.

However, after banging my head against problems for the last day and a half
I'm starting to get frustrated with the language. There are all these annoying
limitations. The two that have given me the biggest problems so far are the
inability to trap and use right click events (without that damn menu appearing)
and just now I've run over something that seems even more implausable - the 256
levels of recursion limit.

Now I fully understand *why* Macromedia put this limit in, it's to protect
programmers from their own mistakes, but (a) 256 levels is FAR too few and (b)
it should be something that competent programmers can turn off.

PLEASE start treating flash like a professional language if you want
professional programmers to start using it for real applications. If you
continue to restrict the language's capabilities in this way Flash will forever
remain a pretty looking toy.

John

[Ivan Peters]

"floyduk" <webforumsuser@macromedia.com> wrote

> and just now I've run over something that seems even more implausable -
> the 256 levels of recursion limit.
>
> Now I fully understand *why* Macromedia put this limit in, it's to
> protect programmers from their own mistakes, but (a) 256 levels is
> FAR too few and (b) it should be something that competent
> programmers can turn off.

Anything involving that many levels of recursion will be much faster and use
much less memory if done non-recursively.

[Mark Redman]

> Anything involving that many levels of recursion will be much faster and
use

> much less memory if done non-recursively.

Can you give us an example of converting a recursive function into a non
recursive function?

[floyduk]

> Anything involving that many levels of recursion will be much faster and use

> much less memory if done non-recursively.

Using less memory perhaps but not faster. Entertaining as it is for you to
presume about what I'm trying to achieve there are times when recursion is a
valuable tool.

John

[Ivan]

"Mark Redman" <co.uk> wrote 

Walking a tree depth first.

Recursive:

function walkNode(currentNode:Object) {
trace(currentNode.name);
for (i:Number = 0; i < currentNode.numChildren; i++) {
walkNode(currentNode.children[i]);
}
}


Non-recursive:

function walkTree(theTree:Object) {
var nodeStack:Array = new Array;
var indexStack:Array = new Array;

trace(theTree.name);
var currentNode:Object = theTree;
var currentIndex:Number = 0;
var done:Boolean = false;

while (!done) {
trace(currentNode.children[currentIndex].name);
if (currentNode.children[currentIndex].numChildren > 0) {
nodeStack.push(currentNode);
indexStack.push(currentIndex);
currentNode = currentNode.children[currentIndex];
currentIndex = 0;
} else {
currentIndex++;
while (currentIndex >= currentNode.numChildren) {
if (nodeStack.length == 0) {
done = true;
} else {
currentNode = nodeStack.pop();
currentIndex = indexStack.pop() + 1;
}
}
}
}
}

(The array code could be optimised for better performance but this keeps it
readable)

It's certainly not easy and I wouldn't bother doing it unless I had a
specific reason (memory/performance problems or a recursion limit in the
language). Any performance/memory improvements in the above example are
pretty dubious, but anything involving more complex processing of each node
may well benefit when the number of recursions gets high.