package nl.bluering;
import java.io.*;
import java.util.*;
/**
* A CoolFileHandle can be used to read files. It is cool
* because it can tokenize the file: with get you can ask 
* for a token that matches the given regular expression. This makes
* it ideal for building parsers with.
* Another cool feature is that you can rewind the file to a previous
* position (also very handy for parsing).
*/


public class CoolFileHandle
{
 LineNumberReader f;
 char last=' ';
 boolean EOF=false;
 
/**
* creates a CFH for parsing the given string. Good for testing.
* @param text the string to parse
* @throws Exception in case something went wrong with the file.
*/
 public CoolFileHandle(String text)
 throws Exception
 {f=new LineNumberReader(new PushbackReader(new StringReader(text)));
  read();
 }
/**
* parses the given file.
* @param ff the file to open
* @throws Exception in case something went wrong with the file.
*/
 public CoolFileHandle(File ff)
  throws Exception
 {
  try
  {
   f=new LineNumberReader(new PushbackReader(new FileReader(ff)));
  }catch(Exception e)
  {die("IOException when opening file "+ff);
  }
  read();
 }
 StringBuffer pbbuf;
 int pos;
 
 /**
 * closes the CFH. You need to do this when you are finished. 
 * If an exception was thrown, the CFH is already closed. But it doesn't
 * hurt to close a CFH twice. 
 */
 public void close()
  {try {f.close();}catch(Exception e){}
  }
  
 public boolean EOF()
 {return EOF&&(pbbuf==null||pos==pbbuf.length());
 }
  
  
  
 void read()
  throws Exception
  {
   if (pbbuf!=null)
   {
    if(pos<pbbuf.length())
    {
    	last=pbbuf.charAt(pos++); 
    	return;
    }
	else if(!buffering)
	 pbbuf=null;
   }
   int l=-1;
   try
   {l=f.read();}catch(IOException e)
   	{die("IO error in file"+e);}
   if (l==-1&&EOF)
 	{die("reading past end of file");}
   else if(l==-1)
 	  {EOF=true;close();last=' ';}
   last=(char)l;
   if(buffering)
   {
   	pbbuf.append(last);
    pos++;
   }
  }
  char lastread()
   throws Exception
  {char r=last;
   read();
   return r;  
  }
  
  
 void die(String message)
  throws Exception
 {
  close();
  if(f!=null)
  	throw new Exception(message+"(line "+f.getLineNumber()+")");
  throw new Exception(message+"(-1)");
 }
 
 /**
 * get the current position. It only works if buffering is on..
 * @return -1 if buffering s off, or another integer that you should not
 * inspect but only give to setpos.
 */
 public int getpos()
 {if(buffering) return pos;
  return -1; 
 }
 /**
 * with setpos you can return to a previous position. Do not use
 * it to jump forward. It only works if you turned buffering on.
 * @param i an integer that you got from getpos()
 */ 
 public void setpos(int i)
 {
  if (buffering)
  {
   pos=i;
   last=pbbuf.charAt(pos-1); 
  }
 }
 boolean buffering=false;
 
 /**
 * buffer(true) enables buffering
 * buffer(false) disables buffering. To flush the buffer, you
 * should do buffer(false);buffer(true);
 */
 public void buffer(boolean on)
 {
  if(buffering==on)
  	return;
  buffering=on;	
  if(on)
  {
   pbbuf=new StringBuffer();
   pbbuf.append(last);
   pos=1; 
  }
 }
 
 public boolean lastin(String s)
 {return s.indexOf(last)!=-1;
 }
 public void pushback(String s)
 {setpos(getpos()-s.length());
 }
 
 
 /**
 * get returns a part of the stream that matches the given
 * regular expression. It returns null if there is no match.
 * the known expressions are(in string notation):
 * <dl>
 * <dt>in(abc)</dt><dd>matches one character if it is a,b or c</dd>
 * <dt>out(abc)</dt><dd> matches one character that is not in abc</dd>
 * <dt>ignore(sub1)</dt><dd>tries to get sub1 from the stream, but does not return it</dd>
 * <dt>insert(abc)</dt><dd>returns abc without doing anything with the file
 * .You can say it is the opposite of ignore.</dd>
 * <dt>not(sub1)</dt><dd>returns the empty string if it can't get sub1</dd>
 * <dt>or(sub1,sub2)</dt><dd>first tries to get sub1, then tries sub2</dd>
 * <dt>quote(abc)</dt><dd>tries to get "abc" from the string</dd>
 * <dt>and(sub1,sub2)</dt><dd>tries to get sub1 followed by sub2 from the stream</dd>
 * <dt>few(sub1)</dt><dd>tries to get any number of sub1 from the stream. It is lazy,
 * so it will try to get as few as possible first. Note that few is more efficient
 * than many</dd>
 * <dt>many(sub1)</dt><dd>tries to get any number of sub1 from the stream. It is greedy,
 * so it tries to get as much sub1 as possible. Note that this is just a search order 
 * difference, because it will backtrack if the next element fails.</dd>
 * <dt>allin(abc)</dt><dd>This parses all characters that appear in abc. It does not
 * do backtracking like many or few. It is thus very efficient.</dd>
 * <dt>allout(abc)</dt><dd>The opposite of allin: it gets all characters outside abc</dd>
 * <dt>maybe(sub1)</dt><dd>parses sub1 if available, otherwise just return the empty string.</dd>
 * <dt>dontcare(sub1)</dt><dd>This is equal to ignore(maybe(sub1))</dd>
 * </dl>
 * @throws Exception if a technical error with the current file happened
 *
 */
 public String get(Expression pattern)
 throws Exception
 {
  String r;
  if (!buffering)
  {buffer(true);
   r=get(pattern,null);
   buffer(false);
  }
  else
   r=get(pattern,null);
  return r;
 }
 static int MAX=100;
 
 String get(Expression pattern, Expression rest)
 throws Exception
 {
  if(pattern==null)
  	return "";
  String r="",s=null;
  int pos1=getpos();
  if(pattern.isfunction("in"))
  {if(!EOF()&&pattern.get(0).toString().indexOf(last)!=-1)
   {
	return dotherest(""+lastread(),rest,pos1);
   }
   return restore(pos1);
  }
  else if(pattern.isfunction("allin"))
  {
   StringBuffer sb=new StringBuffer();
   String arg=pattern.get(0).toString();
   while(!EOF()&&arg.indexOf(last)!=-1)
   {
   	sb.append((char)lastread());
   }
   s=get(rest,null);
   if(s!=null)
  	return sb.toString()+s;
   setpos(pos1);
   return null;
  }
  else if(pattern.isfunction("out"))
  {if(!EOF()&&pattern.get(0).toString().indexOf(last)==-1)
   {
   	char l=lastread();
    s=get(rest,null);
    if(s!=null)
  	 return l+s;
    setpos(pos1);
   }
   return null;
  }
  else if(pattern.isfunction("allout"))
  {
   StringBuffer sb=new StringBuffer();
   String arg=pattern.get(0).toString();
   while(!EOF()&&arg.indexOf(last)==-1)
   {
   	sb.append((char)lastread());
   }
   s=get(rest,null);
   if(s!=null)
  	return sb.toString()+s;
   setpos(pos1);
   return null;
  }
  else if(pattern.isfunction("ignore",1))
  {
   if(get(pattern.get(0),null)==null)
   	return restore(pos1);
   return get(rest,null);
  }
  else if(pattern.isfunction("insert",1))
  {
   return pattern.get(0).toString()+get(rest,null);
  }
  else if(pattern.isfunction("replace"))
  {
   if(get(pattern.get(0),null)!=null)
   	return dotherest(pattern.get(1).toString(),rest,pos1);
   return restore(pos1);
  }

  else if(pattern.isfunction("not"))
  {
   if(get(pattern.get(0),null)==null)
    return get(rest,null);
   else
    return restore(pos1);
  }
  else if (pattern.isfunction("dontcare"))
  { 
   get(pattern.get(0),null);
   return dotherest("",rest,pos1);
  }
  else if (pattern.isfunction("maybe"))
  { 
   r=get(pattern.get(0),null);
   if(r==null)
   	 r="";
   return dotherest(r,rest,pos1);
  }
  
  else if (pattern.isfunction("or"))
  {for(int i=0;i<pattern.getc();i++)
   {
	r=get(pattern.get(i),rest);
    if(r!=null)
		return r;
   }
   return null;	
  }
  else if(pattern.isfunction("quote"))
  {String c = pattern.get(0).toString();  
   int l = c.length();
   for(int i=0; i<l; i++)
   {
   	if (EOF()||lastread()!=c.charAt(i))
	 return restore(pos1);
   }
   return dotherest(c,rest,pos1);
  }
  else if(pattern.isfunction("and"))
  {
   int argc=pattern.getc();
   if(argc==1)
   	return get(pattern.get(0),rest);
   Expression e=new Expression("and",argc);
   for(int i=1;i<argc;i++)
   	e.add(pattern.get(i));
   e.add(rest);	
   return get(pattern.get(0),e);
  }
  else if (pattern.isfunction("few"))
  {
   int min=0,max=MAX;
   if (pattern.getc()==3)
   {min = Integer.parseInt(get(pattern.get(1),null));
    max = Integer.parseInt(get(pattern.get(2),null));
   }
   
   String c;
   r="";
   int count=0;
   for(;count<min;count++)
   {c = get(pattern.get(0),null);
    if(c==null)
    {setpos(pos1);
	 return null;
	}
	r+=c;
   }
   for(;count<max;count++)
   {c = get(rest, null);
	if (c==null)
	{ c = get(pattern.get(0),null);
      if(c==null)
      {setpos(pos1);
	   return null;
	  }
	  r+=c;
	}
	else 
	 return r+c;
   }
   setpos(pos1);
   return null;
  }
  else if(pattern.isfunction("many"))
  {
   String c;
   r="";
   int[] positions=new int[10000];
   String[] results=new String[10000];
   int count=0;
   for(;count<10000;count++)
   {
    positions[count]=getpos();
	p("positions[count]"+positions[count]);
	results[count]=get(pattern.get(0),null);
    if(results[count]==null)
		break;
   }
   for(;count>=0;count--)
   {
    c=get(rest,null);
	if (c!=null)
	{
	 r="";
	 for(int i=0;i<count;i++)
	 	r+=results[i];
	 return r+c;	
	}
    setpos(positions[count]);
   }  
   setpos(pos1);
   return null;
  }
  else 
  	throw new Exception("no regexp:"+pattern);
  //return null;
 }
  
 static void p(String s)
 {System.out.println(s);
 } 
 
 /**
 * parser the rest term. and returns the result of that prepended with part1.
 * it returns null and resets the handle to startposition if it fails.
 */
 String dotherest(String part1,Expression rest, int startposition)
 throws Exception
 {String s=get(rest,null);
  if(s!=null)
   return part1+s;
  return restore(startposition);
 }
 
 /**
 *returns null and resets the handle to startposition 
 */
 String restore(int startposition)
 {setpos(startposition);
  return null;  
 }
 
 /**
 * test the class. You do not need this function, unless you are 
 * modifying this class .
 */
  
 public static void main(String[] ps)
 {
  try
  {
  CoolFileHandle cfh1=new CoolFileHandle("abcd3b");
  Expression e1=new Expression("in",1).add("abcdefghi");
  Expression e2=new Expression("in",1).add("12345");
  Expression e3=new Expression("many",1).add(e1);
  Expression e4=new Expression("or",2).add(e3).add(e1);
  
  cfh1.buffer(true);
  int i=cfh1.getpos();
  p(":"+cfh1.lastread());
  p(":"+cfh1.lastread());
  p(":"+cfh1.lastread());
  cfh1.setpos(i+1);
  p(":"+cfh1.lastread());
  p(":"+cfh1.lastread());
  p(":"+cfh1.lastread());
  cfh1.setpos(i);
  p(">"+cfh1.get(e4));
  }catch(Exception e)
  {e.printStackTrace();
  }
 
 } 
 
 
}