package org.paneris.bibliomania.metasearch.util;
   
   public class HackParser {
     protected static class ParseException extends RuntimeException {
       private int offset;
       private String reason;
       public ParseException(int offset, String expected) {
         super();
         this.offset = offset;
        this.reason = expected;
      }
      private static final long serialVersionUID = 1L;
      /**
       * {@inheritDoc}
       * @see java.lang.Throwable#getMessage()
       */
      public String getMessage() {
        return reason + " at  " + offset;      
      }
    }
  
    protected byte[] text;
    protected int here = 0;
  
    public HackParser(byte[] text) {
      this.text = text;
      //System.err.println(new String(text));
    }
  
    protected final void skipTo(byte c) {
     // System.err.println("here:" + here);
     // System.err.println(new String(text));
     // System.err.println("length:" +text.length);
      
      while (text[here++] != c);
    }
  
    protected final void skipTo(byte c, byte d) {
      for (;;) {
        byte t = text[here++];
        if (t == c || t == d) break;
      }
    }
  
    public static int indexOf(byte[] text, byte[] s) {
      byte s0 = s[0];
      int l = text.length - s.length;
      for (int h = 0; h <= l; ++h) {
        if (text[h] == s0) {
          for (int i = 1;; ++i) {
            if (i >= s.length)
              return h;
            if (text[h + i] != s[i])
              break;
          }
        }
      }
  
      return -1;
    }
  
    protected final void skipTo(byte[] s) {
      // FIXME dumb way: could use skip table etc.
      int startFrom = here;
      for (;;) {
        skipTo(s[0]);
        int herePointer = here;
        //System.err.println("Skipped to " + here + " to find first char of " + new String(s));
        for (int i = 1;; ++i, ++herePointer) {
          if (i >= s.length) {
            here = herePointer;
            System.err.println("Found:" + new String(s));
            return;
          }
          if (herePointer == text.length) {
            System.err.println(new String(text));
            throw new RuntimeException("String \"" + new String(s) + 
                "\" not found starting at " + startFrom + " and looking to " + herePointer );
          }
          if (text[herePointer] != s[i])
            break;
        }
      }
    }
  
    protected final void skipRealSpace() {
      while (Character.isWhitespace((char)text[here]))
        ++here;
    }
  
    protected final boolean skipMaybe(byte[] s) {
      if (here + s.length > text.length)
        return false;
  
      for (int i = 0; i < s.length; ++i)
        if (text[here + i] != s[i])
          //          Character.toLowercase(text[here + i]) != Character.toLowercase(s[i]))
          return false;
  
     here += s.length;
     return true;
   }
 
   protected static final byte[] nbsp = "&nbsp;".getBytes();
 
   protected final void skipSpace() {
     do
       skipRealSpace();
     while (skipMaybe(nbsp));
   }
 
   protected final String plaintext(byte term) {
     skipSpace();
     int start = here;
     if (term == 0)
       skipTo((byte)'<');
     else
       skipTo((byte)'<', term);
 
     int end = here - 2;
     while (Character.isWhitespace((char)text[end]))
       --end;
 
     ++end;
 
     if (end <= start)
       throw new ParseException(here, "at end");
 
     String it = new String(text, start, end - start);
 
     while (it.endsWith("&nbsp;"))
       it = it.substring(0, it.length() - 6).trim();
 
     return it;
   }
 
   protected final String plaintext() {
     return plaintext((byte)'\0');
   }
 
   protected final String digits() {
     int start = here;
     if (!Character.isDigit((char)text[here]))
       throw new ParseException(here, "not digit");
     ++here;
     while (Character.isDigit((char)text[here]))
       ++here;
     return new String(text, start, here - start);
   }
 
   protected final String quotedStringFromBack(int off) {
     int start;
     for (start = here - off; text[start] != '"'; --start);
     skipTo((byte)'"');
     return new String(text, start + 1, here - start - 2);
   }
 }