import java util import java lang Object import java util ArrayList im

import java.util.*;
import java.lang.Object;

import java.util.ArrayList;

import java.io.File;
import java.io.InputStreamReader;
import java.io.FileInputStream;
import java.lang.String;

class Reader {
private File openedFile_;
private BufferedReader reader_;
private ArrayList<String> readedText_;
public Reader(String path) {
openedFile_ = new File(path);
try {
reader_ = new BufferedReader(new InputStreamReader(new FileInputStream(openedFile_), "UTF-8"));
} catch (UnsupportedEncodingException exc) {
System.out.println(" UTF-8 exception. " + exc.getMessage());
} catch (FileNotFoundException exc) {
System.out.println("File Not Found. " + exc.getMessage());
}
readedText_ = new ArrayList<String>();
}
public ArrayList<String> Read() {
String currentString;
try {
while((currentString = reader_.readLine()) != null) {
readedText_.add(currentString);
}
} catch (IOException exc) {
System.out.println("IOException while reading file. " + exc.getMessage());
}
return new ArrayList<String>(readedText_);
}
} 

public class Position implements Comparable<Position> {
    private String text;
    private int line, pos, index;

    public Position (String text) {
        this.text = text;
        line = pos = 1;
		index = 0; 
    }

    public String Text(){return text;}
    public int Line(){return line;}
    public int Pos(){return pos;}
    public int Index(){return index;}
    public Position copyPos(){
        return new Position(text, line, pos, index);
    }

    public int compareTo (Position other){
        return Integer.compare(index, other.index);
    }

    public String toString(){
        return "(" + line + ',' + pos + ')';
    }

    public int cP() {
        if (index == text.length())
            return -1;
        return Character.codePointAt(text, index);
    }

    public boolean isWhiteSpace() {
        return Character.isWhitespace(cP());
    }

    public boolean isLetter() {
        return Character.isLetter(cP());
    }

    public boolean isLetterOrDigit() {
        return Character.isLetterOrDigit(cP());
    }

    public boolean isDecimalDigit() {
        return (index != text.length() &&
                text.charAt(index) >= '0' && text.charAt(index) <= '9');
    }

    public boolean isNewLine() {
        if (index == text.length())
            return true;
        if (text.charAt(index) == '\r' &&
                index + 1 < text.length())
            return (text.charAt(index + 1) == '\n');

        return (text.charAt(index) == '\n');
    }

    public void iterate() {
        if (index < text.length()) {
            if (isNewLine()) {
                if (text.charAt(index) == '\r')
                    index++;
                line++;
                pos = 1;
            } else {
                if (Character.isHighSurrogate(text.charAt(index))) {
                    index++;
                }
                pos++;
            }
            index++;
        }
    }
}


public class Fragment {
    private Position starting, following;

    public Fragment (Position starting , Position following)
    {
        this.starting = starting;
        this.following = following;
    }


    public String toString()
    {
        return starting + " - " + following;
    }
	
    public Position Starting() { return starting; }
    public Position Following() { return following; }
}



public abstract class Token {
    private DomainTag tag;
    private Fragment coords;

    protected Token(DomainTag tag, Position starting, Position following) {
        this.tag = tag;
        coords = new Fragment(starting, following);
    }

    public DomainTag Tag() { return tag; }
    public Fragment Coords() { return coords; }
}


public class IdentToken extends Token {
    public int Code;

    public IdentToken(int code, Position starting, Position following){
        super(DomainTag.IDENT, starting, following);
        Code = code;
    }

}


public class NumberToken extends Token {
    public long Value;

    public NumberToken(long val, Position starting, Position following){
        super(DomainTag.NUMBER, starting, following);
        Value = val;
    }
}


public class OperToken extends Token {
    public String Num;

    public OperToken(String num, Position starting, Position following){
        super(DomainTag.OPER, starting, following);
        Num = num;
    }
}


public class Scanner {
    public String program;

    private Compiler compiler;
    private Position cur;
    private ArrayList<Fragment> comments;

    public ArrayList<Fragment> Comments(){
        return comments;
    }

    public Scanner (String program, Compiler compiler){
        this.compiler = compiler;
        cur = new Position(this.program = program);
        comments = new ArrayList<Fragment>();
    }

    public Token NextToken(){
        while (cur.cP() != -1){
            while (cur.isWhiteSpace())
                cur.iterate();

            Position start = cur.copyPos();

            switch (cur.cP()){
               case '<':
                   cur.iterate();
                   if (cur.cP() == '='){
                       cur.iterate();
                       return new OperToken("<=", start, cur.copyPos());
                   }

                   if (cur.isDecimalDigit()){
                       long val = 0;
                       while(cur.isDecimalDigit()){
                           val *= 10;
                           val += cur.cP() - '0';
                           cur.iterate();
                       }
                       if (cur.cP() == '>' ) cur.iterate();
                       else compiler.AddMessage( true , cur.copyPos(), " > expected " );

                       return new NumberToken(val, start, cur.copyPos());
                   }
                   break;
               case '=':
                   cur.iterate();
                   if (cur.cP() == '='){
                       cur.iterate();
                       return new OperToken("==", start, cur.copyPos());
                   }
                   return new OperToken("=", start, cur.copyPos());
               default:
                   if (cur.cP() == 'e' || cur.cP() == 'u' || cur.cP() == 'i' || cur.cP() == 'o' || cur.cP() == 'a'){
                       String buf = "";
                       while(cur.isLetterOrDigit()){
                           buf += new String(Character.toChars(cur.cP()));
                           cur.iterate();
                       }
                       return new IdentToken(compiler.AddName(buf), start, cur.copyPos());
                   }
                   if(cur.cP() == -1)
                       return new SpecToken(DomainTag.END_OF_PROGRAM, cur.copyPos(), cur.copyPos() );
                   compiler.AddMessage( true , cur.copyPos(), "unexpected character " + new String(Character.toChars(cur.cP())) );
                   while (!cur.isWhiteSpace() && cur.cP() != -1)
                       cur.iterate();
                   break;
            }
        }
        return new SpecToken(DomainTag.END_OF_PROGRAM, cur.copyPos(), cur.copyPos() );
    }
}




public class main {
    public static void main(String args[]) {
        String program;
        try {
            File f = new File("C:/Users/Denis/file");
            char[] CB = new char[(int) f.length()];
            Reader reader = new InputStreamReader(new FileInputStream(f), "UTF-8");
            reader.read(CB);
            program = new String(CB);
        } catch (Exception ex) {
            System.out.println(ex);
            return;
        }

        Compiler comp = new Compiler();
        Scanner scan = new Scanner(program, comp);

        Token t;
        while( (t = scan.NextToken()).Tag != DomainTag.END_OF_PROGRAM){
            System.out.print(t.Tag + " ");
            System.out.print(t.Coords + " ");
            switch (t.Tag){
                case IDENT:
                    System.out.print(comp.GetName(((IdentToken) t).Code) + "\n");
                    break;
                case OPER:
                    System.out.print(((OperToken)t).Num + "\n");
                    break;
                case NUMBER:
                    System.out.print(((NumberToken)t).Value + "\n");
                    break;
            }
        } 
        comp.OutputMessages();
		
        System.out.println("Program text:");
        System.out.println(program);
    }
}