protected JointSet() 
{

}

 public JointSet(ArrayList children,
    FSet fSet) 
{
        this.children = children;
        this.fSet = fSet;
        this.groupIndex = fSet.getGroupIndex();
}

 public boolean first(AbstractSet set) 
{
        if (children != null) {
            for (Iterator i = children.iterator(); i.hasNext();) {
                if (((AbstractSet) i.next()).first(set)) {
                    return true;
                }
            }
        }
        return false;
}

 public int getGroup() 
{
        return groupIndex;
}

 protected String getName() 
{
        return "JointSet"; //$NON-NLS-1$
}

 public AbstractSet getNext() 
{
        return fSet.getNext();
}

 public boolean hasConsumed(MatchResultImpl matchResult) 
{
        return !(matchResult.getEnd(groupIndex)  >= 0 && matchResult
                .getStart(groupIndex) == matchResult.getEnd(groupIndex));
}

 public int matches(int stringIndex,
    CharSequence testString,
    MatchResultImpl matchResult) 
{
        if (children == null) {
            return -1;
        }
        int start = matchResult.getStart(groupIndex);
        matchResult.setStart(groupIndex, stringIndex);
        int size = children.size();
        for (int i = 0; i <  size; i++) {
            AbstractSet e = (AbstractSet) children.get(i);
            int shift = e.matches(stringIndex, testString, matchResult);
            if (shift  >= 0) {
                return shift;
            }
        }
        matchResult.setStart(groupIndex, start);
        return -1;
}

Returns stringIndex+shift, the next position to match

 public  void processSecondPass() 
{
    	this.isSecondPassVisited = true;
    	if (fSet != null && !fSet.isSecondPassVisited) {
    		/*
    	     * Add here code to do during the pass
             */
   	        /*
    	     * End code to do during the pass
             */
    		fSet.processSecondPass();
    	}
    	if (children != null) {
    		int childrenSize = children.size();
    		for (int i = 0; i <  childrenSize; i++) {
    			AbstractSet child = (AbstractSet) children.get(i);
    			/*
        	     * Add here code to do during the pass
                 */
    			JointSet set = child.processBackRefReplacement();
    			if (set != null) {
    				child.isSecondPassVisited = true;
    				children.remove(i);
    				children.add(i, set);
    			    child = (AbstractSet) set;
    			}
    			/*
        	     * End code to do during the pass
                 */
    			if (!child.isSecondPassVisited) {
    				child.processSecondPass();
    			}
    		}
    	}
    	if (next != null) {
    		super.processSecondPass();
    	}
}

This method is used for traversing nodes after the first stage of compilation.

 public  void setNext(AbstractSet next) 
{
        fSet.setNext(next);
}