Index: /Users/jwang/workspace/lucene_trunk/src/java/org/apache/lucene/queryParser/QueryParser.java
===================================================================
--- /Users/jwang/workspace/lucene_trunk/src/java/org/apache/lucene/queryParser/QueryParser.java	(revision 596402)
+++ /Users/jwang/workspace/lucene_trunk/src/java/org/apache/lucene/queryParser/QueryParser.java	(working copy)
@@ -124,6 +124,12 @@
     static public final Operator AND = new Operator("AND");
   }
 
+  
+  private QueryFactory _queryFactory;
+  
+  public void setQueryFactory(QueryFactory queryFactory){
+    _queryFactory=queryFactory;
+  }
 
   /** Constructs a query parser.
    *  @param f  the default field for query terms.
@@ -133,6 +139,7 @@
     this(new FastCharStream(new StringReader("")));
     analyzer = a;
     field = f;
+    _queryFactory=new QueryFactory();
   }
 
   /** Parses a query string, returning a {@link org.apache.lucene.search.Query}.
@@ -144,7 +151,7 @@
     try {
           // TopLevelQuery is a Query followed by the end-of-input (EOF)
       Query res = TopLevelQuery(field);
-      return res!=null ? res : new BooleanQuery();
+      return res!=null ? res : _queryFactory.newBooleanQuery(false);
     }
     catch (ParseException tme) {
       // rethrow to include the original query:
@@ -459,15 +466,15 @@
       return null;
     else if (v.size() == 1) {
       t = (org.apache.lucene.analysis.Token) v.elementAt(0);
-      return new TermQuery(new Term(field, t.termText()));
+      return _queryFactory.newTermQuery(new Term(field, t.termText()));
     } else {
       if (severalTokensAtSamePosition) {
         if (positionCount == 1) {
           // no phrase query:
-          BooleanQuery q = new BooleanQuery(true);
+          BooleanQuery q = _queryFactory.newBooleanQuery(true);
           for (int i = 0; i < v.size(); i++) {
             t = (org.apache.lucene.analysis.Token) v.elementAt(i);
-            TermQuery currentQuery = new TermQuery(
+            TermQuery currentQuery = _queryFactory.newTermQuery(
                 new Term(field, t.termText()));
             q.add(currentQuery, BooleanClause.Occur.SHOULD);
           }
@@ -475,7 +482,7 @@
         }
         else {
           // phrase query:
-          MultiPhraseQuery mpq = new MultiPhraseQuery();
+          MultiPhraseQuery mpq = _queryFactory.newMultiPhraseQuery();
           mpq.setSlop(phraseSlop);
           List multiTerms = new ArrayList();
           for (int i = 0; i < v.size(); i++) {
@@ -491,7 +498,7 @@
         }
       }
       else {
-        PhraseQuery q = new PhraseQuery();
+        PhraseQuery q = _queryFactory.newPhraseQuery();
         q.setSlop(phraseSlop);
         for (int i = 0; i < v.size(); i++) {
           q.add(new Term(field, ((org.apache.lucene.analysis.Token)
@@ -618,7 +625,7 @@
     if (clauses.size()==0) {
       return null; // all clause words were filtered away by the analyzer.
     }
-    BooleanQuery query = new BooleanQuery(disableCoord);
+    BooleanQuery query = _queryFactory.newBooleanQuery(disableCoord);
     for (int i = 0; i < clauses.size(); i++) {
       query.add((BooleanClause)clauses.elementAt(i));
     }
@@ -691,7 +698,7 @@
       termStr = termStr.toLowerCase();
     }
     Term t = new Term(field, termStr);
-    return new PrefixQuery(t);
+    return _queryFactory.newPrefixQuery(t);
   }
 
 
@@ -712,7 +719,7 @@
       termStr = termStr.toLowerCase();
     }
     Term t = new Term(field, termStr);
-    return new FuzzyQuery(t, minSimilarity, fuzzyPrefixLength);
+    return _queryFactory.newFuzzyQuery(t, minSimilarity, fuzzyPrefixLength);
   }
 
   /**
Index: /Users/jwang/workspace/lucene_trunk/src/java/org/apache/lucene/queryParser/QueryFactory.java
===================================================================
--- /Users/jwang/workspace/lucene_trunk/src/java/org/apache/lucene/queryParser/QueryFactory.java	(revision 0)
+++ /Users/jwang/workspace/lucene_trunk/src/java/org/apache/lucene/queryParser/QueryFactory.java	(revision 0)
@@ -0,0 +1,69 @@
+package org.apache.lucene.queryParser;
+
+import org.apache.lucene.index.Term;
+import org.apache.lucene.search.BooleanQuery;
+import org.apache.lucene.search.FuzzyQuery;
+import org.apache.lucene.search.MultiPhraseQuery;
+import org.apache.lucene.search.PhraseQuery;
+import org.apache.lucene.search.PrefixQuery;
+import org.apache.lucene.search.TermQuery;
+
+/**
+ * Factory to produce leaf level query instances used by QueryParser.
+ */
+public class QueryFactory{
+  
+  /**
+   * Builds a new BooleanQuery instance
+   * @param disableCoord disable coord
+   * @return new BooleanQuery instance
+   */
+  public BooleanQuery newBooleanQuery(boolean disableCoord){
+   return new BooleanQuery(disableCoord); 
+  }
+  
+  /**
+   * Builds a new TermQuery instance
+   * @param term term
+   * @return new TermQuery instance
+   */
+  public TermQuery newTermQuery(Term term){
+    return new TermQuery(term);
+  }
+  
+  /**
+   * Builds a new PhraseQuery instance
+   * @return new PhraseQuery instance
+   */
+  public PhraseQuery newPhraseQuery(){
+    return new PhraseQuery();
+  }
+  
+  /**
+   * Builds a new MultiPhraseQuery instance
+   * @return new MultiPhraseQuery instance
+   */
+  public MultiPhraseQuery newMultiPhraseQuery(){
+    return new MultiPhraseQuery();
+  }
+  
+  /**
+   * Builds a new PrefixQuery instance
+   * @param prefix Prefix term
+   * @return new PrefixQuery instance
+   */
+  public PrefixQuery newPrefixQuery(Term prefix){
+    return new PrefixQuery(prefix);
+  }
+  
+  /**
+   * Builds a new FuzzyQuery instance
+   * @param term Term
+   * @param minimumSimilarity minimum similarity
+   * @param prefixLength prefix length
+   * @return new FuzzyQueryInstance
+   */
+  public FuzzyQuery newFuzzyQuery(Term term, float minimumSimilarity, int prefixLength){
+    return new FuzzyQuery(term,minimumSimilarity,prefixLength);
+  }
+}