Using Regular Expressions for Completion

Question

I'm trying to build a text completer for a simple little editor. The general idea is that I have a regular expression which describes the syntax of an expression and a set of strings which are all semantically valid cases of the expression (the latter of which is not particularly important to my problem). I would like to be able to determine, using the expression described, whether or not a section of text is capable of beginning a syntactically valid expression, not matching it.
For example, given the expression
"#[A-Za-z0-9]#" the string "#name#" is syntactically valid, whereas the string "#_blarg" is not. What I would like to do is be able to determine that "#partial" has the potential to match the pattern with more input, even if it doesn't yet. Specifically, the eventual use will be in such a case as the string X=#partial+3. If the cursor is positioned before the "+" and my user presses the completion keystroke, I want to recognize that "#partial" is what I need to recognize. Also, positioning the cursor immediately after the "=" and pressing the keystroke will do nothing, since nothing before the "=" is capable of matching the pattern properly.
Is this possible? I don't have to use this exact approach, but it is important that I be able to use the regular expression in detecting a partially completed expression. If I can, the set of regular expressions which already exist in the code can be used to drive the auto completer. Otherwise, I'll have to write a special recognition module for each case; that wouldn't be pretty.
Thanks for your time! I'll provide other information upon request, if it'd help. :)

Answer 1

Thank you both for discussing this; it has definitely helped me in reaching a better understanding of uncle_alice's answer to my problem. I've adjusted my code to use this approach and, for the most part, it seems to work.
I say "for the most part" because I am compiling Patterns with the case insensitivity flag. This appears to do horrible, horrible things. Take a look at the following code, modified from uncle_alice's example:
String[] str = {"#test#hello", "#tes", "blargblarg", "", "#test#", "S"};
String rgx = "#[A-Za-z0-9]+#";
Pattern pc = Pattern.compile(rgx);
Pattern pi = Pattern.compile(rgx, Pattern.CASE_INSENSITIVE);
for (String s : str)
    System.out.println("    For string: "+s);
    for (Pattern p : new Pattern[]{pc, pi}) // once for each pattern
        Matcher m = p.matcher(s);
        if (m.matches())
            System.out.printf("Matched '%s'", m.group());
        } else
            System.out.print("No match");
        System.out.println("; hitEnd = " + m.hitEnd());
}That produces the following output:
    For string: #test#hello
No match; hitEnd = false
No match; hitEnd = true
    For string: #tes
No match; hitEnd = true
No match; hitEnd = true
    For string: blargblarg
No match; hitEnd = false
No match; hitEnd = true
    For string:
No match; hitEnd = true
No match; hitEnd = true
    For string: #test#
Matched '#test#'; hitEnd = false
Matched '#test#'; hitEnd = false
    For string: S
No match; hitEnd = false
No match; hitEnd = trueIt would seem that, with the case-insensitive flag set, hitEnd always returns true unless a match is found. Why is this? I find it quite confusing.
I can adjust my design to accomodate if this problem cannot be circumvented; however, I'd like to understand what has going wrong here. :)
Cheers! Thanks so much for all your help!