/*
 * [The "BSD license"]
 *  Copyright (c) 2010 Terence Parr
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *  1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *  3. The name of the author may not be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 *  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 *  OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 *  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
package org.antlr.analysis;

import org.antlr.misc.Utils;

An NFA state, predicted alt, and syntactic/semantic context.
 The syntactic context is a pointer into the rule invocation
 chain used to arrive at the state.  The semantic context is
 the unordered set semantic predicates encountered before reaching
 an NFA state.
/** An NFA state, predicted alt, and syntactic/semantic context.
 *  The syntactic context is a pointer into the rule invocation
 *  chain used to arrive at the state.  The semantic context is
 *  the unordered set semantic predicates encountered before reaching
 *  an NFA state.
 */
public class NFAConfiguration {
    
The NFA state associated with this configuration /** The NFA state associated with this configuration */
    public int state;

    
What alt is predicted by this configuration /** What alt is predicted by this configuration */
    public int alt;

    
What is the stack of rule invocations that got us to state? /** What is the stack of rule invocations that got us to state? */
    public NFAContext context;

    
The set of semantic predicates associated with this NFA
 configuration.  The predicates were found on the way to
 the associated NFA state in this syntactic context.
 Set<AST>: track nodes in grammar containing the predicate
 for error messages and such (nice to know where the predicate
 came from in case of duplicates etc...).  By using a set,
 the equals() method will correctly show {pred1,pred2} as equals()
 to {pred2,pred1}.
/** The set of semantic predicates associated with this NFA
     *  configuration.  The predicates were found on the way to
     *  the associated NFA state in this syntactic context.
     *  Set&lt;AST&gt;: track nodes in grammar containing the predicate
     *  for error messages and such (nice to know where the predicate
     *  came from in case of duplicates etc...).  By using a set,
     *  the equals() method will correctly show {pred1,pred2} as equals()
     *  to {pred2,pred1}.
     */
    public SemanticContext semanticContext = SemanticContext.EMPTY_SEMANTIC_CONTEXT;

    
Indicate that this configuration has been resolved and no further
 DFA processing should occur with it.  Essentially, this is used
 as an "ignore" bit so that upon a set of nondeterministic configurations
 such as (s|2) and (s|3), I can set (s|3) to resolved=true (and any
 other configuration associated with alt 3).
/** Indicate that this configuration has been resolved and no further
     *  DFA processing should occur with it.  Essentially, this is used
     *  as an "ignore" bit so that upon a set of nondeterministic configurations
     *  such as (s|2) and (s|3), I can set (s|3) to resolved=true (and any
     *  other configuration associated with alt 3).
     */
    protected boolean resolved;

    
This bit is used to indicate a semantic predicate will be
 used to resolve the conflict.  Method
 DFA.findNewDFAStatesAndAddDFATransitions will add edges for
 the predicates after it performs the reach operation.  The
 nondeterminism resolver sets this when it finds a set of
 nondeterministic configurations (as it does for "resolved" field)
 that have enough predicates to resolve the conflit.
/** This bit is used to indicate a semantic predicate will be
     *  used to resolve the conflict.  Method
     *  DFA.findNewDFAStatesAndAddDFATransitions will add edges for
     *  the predicates after it performs the reach operation.  The
     *  nondeterminism resolver sets this when it finds a set of
     *  nondeterministic configurations (as it does for "resolved" field)
     *  that have enough predicates to resolve the conflit.
     */
    protected boolean resolveWithPredicate;

    
Lots of NFA states have only epsilon edges (1 or 2).  We can
 safely consider only n>0 during closure.
/** Lots of NFA states have only epsilon edges (1 or 2).  We can
     *  safely consider only n&gt;0 during closure.
     */
    protected int numberEpsilonTransitionsEmanatingFromState;

    
Indicates that the NFA state associated with this configuration
 has exactly one transition and it's an atom (not epsilon etc...).
/** Indicates that the NFA state associated with this configuration
     *  has exactly one transition and it's an atom (not epsilon etc...).
     */
    protected boolean singleAtomTransitionEmanating;

	//protected boolean addedDuringClosure = true;

	public NFAConfiguration(int state,
                            int alt,
                            NFAContext context,
                            SemanticContext semanticContext)
    {
        this.state = state;
        this.alt = alt;
        this.context = context;
        this.semanticContext = semanticContext;
    }

    
An NFA configuration is equal to another if both have
 the same state, the predict the same alternative, and
 syntactic/semantic contexts are the same.  I don't think
 the state|alt|ctx could be the same and have two different
 semantic contexts, but might as well define equals to be
 everything.
/** An NFA configuration is equal to another if both have
     *  the same state, the predict the same alternative, and
     *  syntactic/semantic contexts are the same.  I don't think
     *  the state|alt|ctx could be the same and have two different
     *  semantic contexts, but might as well define equals to be
     *  everything.
     */
	@Override
    public boolean equals(Object o) {
		if ( o==null ) {
			return false;
		}
        NFAConfiguration other = (NFAConfiguration)o;
        return this.state==other.state &&
               this.alt==other.alt &&
               this.context.equals(other.context)&&
               this.semanticContext.equals(other.semanticContext);
    }

	@Override
    public int hashCode() {
        int h = state + alt + context.hashCode();
        return h;
    }

	@Override
	public String toString() {
		return toString(true);
	}

	public String toString(boolean showAlt) {
		StringBuilder buf = new StringBuilder();
		buf.append(state);
		if ( showAlt ) {
			buf.append("|");
			buf.append(alt);
		}
		if ( context.parent!=null ) {
            buf.append("|");
            buf.append(context);
        }
        if ( semanticContext!=null &&
             semanticContext!=SemanticContext.EMPTY_SEMANTIC_CONTEXT ) {
            buf.append("|");
			String escQuote = Utils.replace(semanticContext.toString(), "\"", "\\\"");
			buf.append(escQuote);
        }
        if ( resolved ) {
            buf.append("|resolved");
        }
		if ( resolveWithPredicate ) {
			buf.append("|resolveWithPredicate");
		}
		return buf.toString();
    }
}