//
// This software is now distributed according to
// the Lesser Gnu Public License.  Please see
// http://www.gnu.org/copyleft/lesser.txt for
// the details.
//    -- Happy Computing!
//
package com.stevesoft.pat;

import java.util.*;

/**
 Shareware: package pat
 <a href="copyright.html">Copyright 2001, Steven R. Brandt</a>
 */
/**
 * Class Pattern is the base class on which all the other pattern elements are
 * built.
 */

public abstract class Pattern
{
  /**
   * The ESC character, the user can provide his own value for the escape
   * character through regex.esc
   */
  public final static char ESC = '\\';

  final static String PROTECT_THESE = "[]{}(),$,-\"^.";

  /**
   * The interal match function, it must be provided by any class which wishes
   * to extend Pattern.
   */
  public abstract int matchInternal(int i, Pthings p);

  public abstract String toString();

  // Class Pattern is a singly linked list
  // chained together by member next. The member
  // parent is used so that sub patterns can access
  // the chain they are branching from.
  Pattern next = null, parent = null;

  /**
   * This gets the next element of a Pattern that we wish to match. If we are at
   * the end of a subchain of patterns, it will return us to the parent chain.
   */
  public Pattern getNext()
  {
    return next != null ? next : (parent == null ? null : parent.getNext());
  }

  /**
   * Call this method if you have a pattern element that takes a sub pattern
   * (such as Or), and after you have added a sub pattern to the current pattern
   * element.
   */
  public void setParent(Pattern p)
  {
    if (next != null)
    {
      next.setParent(p);
    }
    else
    {
      parent = p;
    }
  }

  /**
   * This determines if the remainder of a Pattern matches. Type "return
   * nextMatch" from within matchInternal if the current Pattern matches.
   * Otherwise, return a -1.
   */
  public int nextMatch(int i, Pthings pt)
  {
    Pattern p = getNext();
    /*
     * if(p == null) return i; return p.matchInternal(i,pt);
     */
    return p == null ? i : p.matchInternal(i, pt);
  }

  /**
   * This is a toString() for the remainder of the Pattern elements after this
   * one. use this when overriding toString(). Called from within toString().
   */
  public String nextString()
  {
    if (next == null)
    {
      return "";
    }
    return next.toString();
  }

  /** a method to detect whether char c is in String s */
  final static boolean inString(char c, String s)
  {
    int i;
    for (i = 0; i < s.length(); i++)
    {
      if (s.charAt(i) == c)
      {
        return true;
      }
    }
    return false;
  }

  /**
   * A method to create a string that protects the characters listed in
   * PROTECT_THESE by prepending the esc character. The esc character itself is
   * automatically protected.
   */
  final static String protect(String s, String PROTECT_THESE, char esc)
  {
    int i;
    StringBuffer sb = new StringBuffer();
    String p = PROTECT_THESE + esc;
    for (i = 0; i < s.length(); i++)
    {
      char c = s.charAt(i);
      if (inString(c, p))
      {
        sb.append(esc);
      }
      sb.append(c);
    }
    return sb.toString();
  }

  /**
   * This can be used to perform a match test from within class Pattern.
   */
  public int match(StringLike s, Pthings pt)
  {
    return matchAt(s, 0, pt);
  }

  /**
   * This can be used to perform a match test from within class Pattern.
   */
  public int matchAt(StringLike s, int i, Pthings pt)
  {
    pt.src = s;
    int r = matchInternal(i, pt);
    if (r < 0)
    {
      return -1;
    }
    mfrom = r < i ? r + 1 : i;
    return r < i ? i - r - 1 : r - i;
  }

  int mfrom = 0;

  // Detect masked characters
  final boolean Masked(int i, Pthings pt)
  {
    return pt.cbits == null ? false : pt.cbits.get(i);
  }

  /** add a Pattern to the singly-linked Pattern chain. */
  public Pattern add(Pattern p)
  {
    if (next == null)
    {
      if (p == null)
      {
        return this;
      }
      next = p;
      p.parent = parent;
      parent = null;
    }
    else
    {
      next.add(p);
    }
    return this;
  }

  /**
   * The minimum number of characters which this pattern element can match.
   */
  public patInt minChars()
  {
    return new patInt(0);
  }

  /**
   * The maximum number of characters which this pattern element can match.
   */
  public patInt maxChars()
  {
    return new patInf();
  }

  /** return minimum number of characters in pattern */
  public final patInt countMinChars()
  {
    Pattern p = this;
    patInt sum = new patInt(0);
    while (p != null)
    {
      sum.pluseq(p.minChars());
      p = p.next;
    }
    return sum;
  }

  /** return maximum number of characters in pattern */
  public final patInt countMaxChars()
  {
    Pattern p = this;
    patInt sum = new patInt(0);
    while (p != null)
    {
      sum.pluseq(p.maxChars());
      p = p.next;
    }
    return sum;
  }

  // This method is only needed by Multi_stage2 so far...
  // the reason is that it may try something else after a
  // match succeeds. OrMark will only record the last thing
  // tried in marks, so we need to backup the result of the
  // last successful match and restore it if the next one
  // does not succeed.
  final int testMatch(Pattern p, int pos, Pthings pt)
  {
    int[] tab = null;
    if (pt.marks != null)
    {
      try
      {
        tab = new int[pt.marks.length];
        for (int i = 0; i < tab.length; i++)
        {
          tab[i] = pt.marks[i];
        }
      } catch (Throwable t)
      {
      }
    }
    int ret = p.matchInternal(pos, pt);
    if (ret < 0)
    {
      pt.marks = tab;
    }
    return ret;
  }

  /**
   * Clones this pattern elements without cloning others in the linked list.
   */
  Pattern clone1(Hashtable h)
  {
    throw new Error("No such method as clone1 for " + getClass().getName());
  }

  Pattern clone(Hashtable h)
  {
    Pattern p = (Pattern) h.get(this);
    if (p != null)
    {
      return p;
    }
    p = clone1(h);
    if (p == null)
    {
      throw new Error("Null from clone1!");
    }
    h.put(this, p);
    h.put(p, p);
    if (next != null)
    {
      p.next = next.clone(h);
    }
    if (parent != null)
    {
      p.parent = parent.clone(h);
    }
    return p;
  }

  public boolean equals(Object o)
  {
    return o == this;
  }
};
