/************************
 * CS211 Fall 2003      *
 * CS211In.java         *
 ************************/

import java.io.*;

// Tokenizer
public class CS211In implements CS211InInterface {
    
    // Instance variable declarations:    
    String Name;
    InputStream in;
    boolean reading_file = false;
    StreamTokenizer tokens;
    boolean errorp = false; // To avoid multiple error messages
    
    // Open a file for input:
    public CS211In (String FileName) {
	try { 
	    Name = FileName;
	    in = new FileInputStream(FileName);
	    reading_file = true;
	    Reader r = new BufferedReader(new InputStreamReader(in));
	    tokens = new StreamTokenizer(r);
	    tokens.wordChars(':',':');
	} catch (Exception e) { // Do not report any exceptions
	    System.out.println("ERROR: Unable to open file " + FileName + " for input\n");
	    errorp = true;
	}
    }
    
    // Open a Reader for input:
    public CS211In (Reader r) {
	Name = "string";
	tokens = new StreamTokenizer(r);
	tokens.wordChars(':',':');
    }
    
	// Open System.in for input:
    public CS211In () {
	Name = "System.in";
	tokens = new StreamTokenizer(new InputStreamReader(System.in));
	tokens.wordChars(':',':');
    }
	
    // Get an integer from file:
    public int getInt () {
	try {
	    if (tokens.nextToken() == tokens.TT_NUMBER)
		return (int)tokens.nval;
	    else
		throw new Exception();
	} catch (Exception e) {
	    if (! errorp)
		System.out.println("ERROR: Attempt to read a non-integer value as an integer\n");
	    errorp = true;
	    return 0;
	}
    }
    
    // Get a word from file:
    public String getWord () {
	try {
	    if (tokens.nextToken() == tokens.TT_WORD)
		return tokens.sval;
	    else 
                throw new Exception();
	} catch (Exception e) {
	    if (! errorp)
		System.out.println("ERROR: Attempt to read a non-word value as a word\n");
	    errorp = true;
	    return "";
	}
    }
    
    // Get an operator (!(wordChar,numberChar,EOF)) from file:
    public char getOp () {
	try {
	    if ((tokens.nextToken() != tokens.TT_NUMBER)
		&& (tokens.ttype != tokens.TT_WORD)
		&& (tokens.ttype != tokens.TT_EOF))
		return (char)tokens.ttype;
	    else
		throw new Exception();
	} catch (Exception e) {
	    if (! errorp) 
		System.out.println("ERROR: Attempt to read non-operator value as an operator\n");
	    errorp = true;
	    return (char)0;
	}
    }
    
    // Peek at the next token and return its "kind":
    public int peekAtKind () { // look at kind of next token w/o eating it
	try {
	    int kind = tokens.nextToken();
	    switch (kind) {
	    case StreamTokenizer.TT_EOF:    tokens.pushBack(); return EOF;
	    case StreamTokenizer.TT_NUMBER: tokens.pushBack(); return INTEGER;
	    case StreamTokenizer.TT_WORD:   tokens.pushBack(); return WORD;
	    default: tokens.pushBack(); return OPERATOR; //character found
	    }
	} catch (Exception e) {
	    if (! errorp) 
		System.out.println("ERROR: Unable to peek into file " + Name);
	    errorp = true;
	    return 0;
	}
    }
    
    // Make sure next token in input is operator c:
    public void match(char c) {
	char n;
	if (peekAtKind() == OPERATOR) {
            n = getOp();
	    if (n == c)
                return;
	    else {
                System.out.println(
				   "Expecting " + c + " but found " + n + " in Line " + lineNo());
		return;
	    }
	} else
            System.out.println("Did not find " + c + " in Line " + lineNo());
    }
    
    // Make sure next token in input is word s:
    public void match(String s) {
	String n;
	if (peekAtKind() == WORD) {
            n = getWord();
	    if (n.equals(s))
                return;
	    else {
                System.out.println("Expecting " + s + " but found " +
                                   n + " in Line " + lineNo());
		return;
	    }
	} else
            System.out.println("Did not find " + s + " in Line " + lineNo());
    }
    
    public boolean check(char c) {
	// Look for c but don't panic if you don't find it:
	if (peekAtKind() == OPERATOR) {
            char n = getOp();
	    if (n == c) 
                return true;
	    else {
                pushBack();
                return false;
            }
	} else 
            return false;
    }
    
    public boolean check(String s) {
	// Look for s but don't panic if you don't find it:
	if (peekAtKind() == WORD) {
            String n = getWord();
	    if (n.equals(s)) 
                return true;
	    else {
                pushBack();
                return false;
            }
	} else 
            return false;
    }
    
    // Pushes one token back into input stream:
    public void pushBack() { tokens.pushBack(); }
    
    // Return the line number:
    public int lineNo()    { return tokens.lineno(); }
    
    // Close file:
    public void close () {
	if (reading_file)
	    try { in.close(); }
	    catch (Exception e) {
		if (! errorp)
		    System.out.println("Error: Unable to close file " + Name);
		errorp = true;
	    }
    }
}