Non-recursion-based regex

Question

I'm doing some heavy duty very special case regexing. If fact I have to build them programatically as the actual regular expressions can grow to over 60,000 characters in length.
I'm doing this in 1.3.1 and have tried a couple free/open source regex packages. As one might imagine, I get StackOverflowErrors very often in every package I've tried.
If this is such a problem with regular expressions, it seems someone would have created a Java regexp package that doesn't rely so heavily on recursion. (In fact people have, in other languages, I just haven't found one in Java).
Anyway, my first question is: is there a Java non-recursion-based regex package out there?
I know I can increase the stack size, but to what?! I build my regexs on the fly, and the data they operate on is also generated on the fly.
I think an OutOfMemoryError with a non-recursive implementation would be a lot less likely that a StackOverFlowError. ???
It's Saturday (as you can see) and it looks more and more like I may have to write/port a regex package that fits the bill. This is really a pain.
Another possibility is to use GNU Kawa (which implements proper tail recursion) to compile a Scheme regexp implementation into something I can use from Java. This seems really convoluted.
Any ideas?

Answer 1

Indeed, a 60,000 char regex is, to be blunt,
ridiculous. There has to be another approach to
whatever problem you are solving (is it biological in
nature, perchance?). It's pattern recongition of structures of objects.
My problem is that what I would REALLY like to do boils down to "regular expressions" over an 2-dimentional array of arbitrary objects, not characters.
As a completely inane example: 3 Strings who's length is between 7 and 19 that don't start with "foo" or "bar", followed by any number of objects implementing Runnable but not Comparable.
I started doing this from scratch, but I thought a faster way to get things done was to cheat.
So I created a system to translate the objects I'm interested in to a "compact" String representation, right now it's about 32 characters long. I can specify properties I'm looking for with this representation, or specify I don't care with '.' values in the fields I don't care about. So for example a lowercase e in a particular index represents non-editable, uppercase means editable, '.' means I don't care. Some field/properties require multiple characters to represent them.
Now the patterns I'm looking for are in a 2 dimensional array of objects.
When you start multiplying hundreds of objects by hundreds of objects by 32 characters per object ... You get a pretty big regex.
Another option I've started is custom, from scracth "Java Object Regular Expressions" or JOREs as I like to call them (I already started coding this and needed a package name).
(Does anything like this already exist? I haven't found it.)
Anyway, 60,000 is bordering on worst case scenarios. It could happen. 7000-ish is a more realistic average I'd expect, but it doesn't make worst cases go away.
It seems even in many smaller cases I get a StackOverflowError, but there are probably more nested .{,}[^]+* type things in those to make them more complex.