//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\
// PLEASE DO NOT EDIT WITHOUT THE EXPLICIT CONSENT OF THE AUTHOR! \\
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

namespace Ilog.Irl
{
  /**
   * @version     Last modified on Tue May 31 20:24:16 2005 by hak
   * @author      <a href="mailto:hak@ilog.fr">Hassan A&iuml;t-Kaci</a>
   * @copyright   &copy; 2004 <a href="http://www.ilog.fr/">ILOG, Inc.</a>
   */

  using Reader = System.IO.TextReader;
  using FileReader = System.IO.StreamReader;

  using StreamTokenizer = Ilog.Language.IO.StreamTokenizer;
  using Ilog.Language.Parsing;

  internal class Tokenizer : FileTokenizer
    {
      private int lineno;
      private string file;
      private Reader reader;
      private StreamTokenizer st;

      internal Tokenizer ()
        {
	}

      internal Tokenizer (string file)
        {
	  this.file = file;
	  SetReader(new FileReader(file));
	}

      public string FileName
        {
	  get { return file; }
	  set { file = value; }
	}

      public int LineNumber
        {
	  get { return lineno; }
	}

      public void SetReader (Reader rd)
        {
	  reader = rd;
	  st = new StreamTokenizer(reader);
	  st.OrdinaryChars("+-.(){}[]<>;,:=!&|*/%");
	  StreamTokenizer.SetType('.',StreamTokenizer.NUMERIC);
	  st.QuoteChar('\'');
	  st.QuoteChar('"');
	  st.WordChars("_@?$");
	}

      public Reader GetReader ()
        {
	  return reader;
	}

      private ParseNode Locate (ParseNode node)
        {
	  return ((ParseNode)node.SetStart(st.TokenStart()).SetEnd(st.TokenEnd())).SetFile(file);
	}

      private ParseNode Integer ()
        {
	  return Locate(DynamicParser.NumberToken("INTEGER_LITERAL",(int)st.NValue));
	}

      private ParseNode FloatingPoint ()
        {
	  return Locate(DynamicParser.NumberToken("FLOATING_POINT_LITERAL",st.NValue));
	}

      private ParseNode String ()
        {
	  return Locate(DynamicParser.SymbolToken("STRING_LITERAL",st.SValue));
	}

      private ParseNode Character ()
        {
	  return Locate(DynamicParser.SymbolToken("CHARACTER_LITERAL",st.SValue));
	}

      private ParseNode Identifier (string symbol)
        {
	  return Locate(DynamicParser.SymbolToken("IDENTIFIER",symbol));
	}

      private ParseNode Variable (string symbol)
        {
	  return Locate(DynamicParser.SymbolToken("VARIABLE",symbol));
	}

      private ParseNode Literal (string s)
        {
	  return Locate(DynamicParser.LiteralToken(s));
	}

      private ParseNode Literal (int c)
        {
	  return Locate(DynamicParser.LiteralToken(((char)c).ToString()));
	}

      public ParseNode NextToken ()
        {
	  ParseNode t = null;
	  int tk = st.NextToken();
	  int nextChar = st.Peek();
	  lineno = st.GetLineNumber();

	  switch (tk)
	    {
	    case StreamTokenizer.TT_SPECIAL:
	      return NextToken();
	    case StreamTokenizer.TT_EOF:
	      t = Locate(DynamicParser.E_O_I);
	      break;
	    case StreamTokenizer.TT_NUMBER:
	      if (st.IsInteger)
		t = Integer();
	      else
		t = FloatingPoint();
	      break;
	    case '"':
	      t = String();
	      break;
	    case '\'':    // NB: this does NOT check what's between single quotes
	      t = Character();
	      break;
	    case StreamTokenizer.TT_WORD:
	      if (Lexicon.IsVariable(st.SValue))
	        {
		  t = Variable(st.SValue);
		  break;
		}
	      if (Lexicon.IsReservedWord(st.SValue))
	        {
		  t = Literal(st.SValue);
		  break;
		}
	      if (Lexicon.IsIdKeyWord(st.SValue))
	        {
		  t = Literal(st.SValue);
		  t.AddAlternative(Identifier(st.SValue));
		  break;
		}
	      t = Identifier(st.SValue);
	      break;
	    case '=': case '!': case '<': case '>':
	    case '&': case '|': case '+': case '-':
	    case '*': case '/': case '%':
	      if (nextChar == '=' ||
		  (tk == nextChar && (tk == '+' || tk == '-' || tk == '&' || tk == '|')))
	        {
		  t = Literal(((char)tk).ToString()+(char)nextChar);
		  st.SkipChar(true);
		  break;
		}
	      goto default;
	    default:
	      t = Literal(tk);
	      break;
	    }
	  return t;
	}
    }
}