Created by natalia on 19 04 14 package CompilerGenerator lex Created b

/**
 * Created by natalia on 19.04.14.
 */
package CompilerGenerator.lex; /**
 * Created by natalia on 05.04.14.
 */

import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import java.io.*;
import java.util.ArrayList;

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_);
    }
}

class Token {
    String type;
    String value;

    public Token(String t, String v) {
        type = t;
        value = v;
    }
}



class Parse {
    private String axiom;
    private List<String> nTerm;
    private List<String> Term;
    HashMap<String, List<String[]>> lRule_rRule;// = new HashMap<String, List<String>>();

    List<Token> tokens = new LinkedList<Token>();

    public Parse() {
        nTerm = new LinkedList<String>();
        Term = new LinkedList<String>();
        lRule_rRule = new HashMap<String, List<String[]>>();

        String s = "bla";
        //if(s.equals("bla"))
        //   System.out.println("yeee ! start with bla");
        //else
        //    System.out.println("oop");
    }

    public void addNTerm(String Nterms) {
        Nterms = Nterms.substring(0, Nterms.length()-1);
        String [] terms = Nterms.split(" ") ;
        for(int i = 1; i < terms.length; i++) {
            nTerm.add(terms[i]);
            System.out.println("nterms: " + terms[i]);
        }
        //nTerm.add(Nterm);
    }

    public void addTerm(String T) {
        T = T.substring(0, T.length()-1);
        String [] terms = T.split(" ") ;
        for(int i = 1; i < terms.length; i++) {
            Term.add(terms[i].split("\"")[1]);
            System.out.println("terms: " + terms[i].split("\"")[1]);
        }
        //System.out.println("!!! " + F("*hhh"));
    }

    public void addAxiom(String a) {
        a = a.substring(0,a.length()-1);
        String toAdd = a.split(" ")[1];
        axiom = toAdd;
        nTerm.add(toAdd);
        System.out.println("axiom: " + axiom);
    }

    public void addRule(String lr, String rr) {
        String []rRules = rr.split("\n");
        System.out.println("rules: " + lr + " - " + rr);
        lRule_rRule.put(lr, new LinkedList<String[]>());
        for(int i = 0; i < rRules.length; i++) {
            String [] s = rRules[i].split(" ");
            String [] news = new String[s.length-1];
            for(int j = 1; j < s.length; j++) {
                if(s[j].charAt(0) == '\"')
                    s[j] = s[j].substring(1, 2);//split("\"")[1];
                news[j - 1] = s[j];
            }
            //System.out.println(" !"+s[j]+"! ");
            lRule_rRule.get(lr).add(news);
            System.out.println("part_of_rule: " + news[0]);
        }
    }

    //----------creating--FIRST--&--FOLLOW------------------------------------

}


public class lexer {
    static private int strNum = 0;
    static private Parse parse = new Parse();

    static List<Token> tokens = new LinkedList<Token>();

    public void addNTerm(String Nterms) {
        Nterms = Nterms.substring(0, Nterms.length()-1);
        String [] terms = Nterms.split(" ") ;
        for(int i = 1; i < terms.length; i++) {
            tokens.add(new Token("NTERM", terms[i]));
            //nTerm.add(terms[i]);
            System.out.println("nterms: " + terms[i]);
        }
        //nTerm.add(Nterm);
    }

    public void addRule(String lr, String rr) {
        String []rRules = rr.split("\n");
        System.out.println("rules: " + lr + " - " + rr);

        tokens.add(new Token("N", lr));
        //lRule_rRule.put(lr, new LinkedList<String[]>());
        for(int i = 0; i < rRules.length; i++) {
            String [] s = rRules[i].split(" ");
            String [] news = new String[s.length-1];
            for(int j = 1; j < s.length; j++) {
                if(s[j].charAt(0) == '\"')
                    s[j] = s[j].substring(1, 2);//split("\"")[1];
                news[j - 1] = s[j];
            }
            //System.out.println(" !"+s[j]+"! ");

            //tokens.add(new Token("", ));
            //lRule_rRule.get(lr).add(news);
            System.out.println("part_of_rule: " + news[0]);
        }
    }

    public void addTerm(String T) {
        T = T.substring(0, T.length()-1);
        String [] terms = T.split(" ") ;
        for(int i = 1; i < terms.length; i++) {
            tokens.add(new Token("T", terms[i].split("\"")[1]));
            //Term.add(terms[i].split("\"")[1]);
            System.out.println("terms: " + terms[i].split("\"")[1]);
        }
        //System.out.println("!!! " + F("*hhh"));
    }



    private void print(String s, int pos, int mend) {
        //    System.out.println("IDENT ("+strNum+","+pos+")-("+strNum+","+(pos+mend)+"): "+s);
    }
    private static void findLex2(String s, Pattern p) {
        int pos = 0;
        Matcher m;
        while(s.length() != 0){
            m = p.matcher(s);
            if(m.find()) {
                if (m.group(1) != null) {
                    System.out.println("RULE II ("+strNum+","+pos+")-("+strNum+","+
                            (pos+m.end())+"): "+m.group(2) +"$$$END$$$");
                    tokens.add(new Token("R", "$RULE"));
                    parse.addRule(m.group(2), m.group(3));
                } else {System.out.println("!!!!!!!!!!!!!!!!!!!!!!!!!");}
                /*for(int i = 0; i < 5; i++) {
                    if(m.group(i) != null)
                        System.out.println(i+ " g: " + m.group(i));
                }*/
                pos += m.end();
                s = s.substring(m.end());
                //System.out.println(s);
                //for(int i = 1; i< 7;i++)
                //    System.out.println("g: " +m.group(i));
            } else {
                pos++;
                if(s.charAt(0) != ' ') {
                    System.out.println("ERROR at (" + strNum + "," + pos + ")");
                }
                s = s.substring(1);
            }
        }
        strNum++;
    }

    private static void findLex(String s, Pattern p) {
        int pos = 0;
        Matcher m;
        while(s.length() != 0){
            m = p.matcher(s);
            if(m.find()) {
                //System.out.println("BBBBBBBBBBBBBBBBBBB");
                if (m.group(2) != null) {
                                System.out.println("KEYWORD ("+strNum+","+pos+")-("+strNum+","+
                                        (pos+m.end())+"): "+m.group(2));
                    tokens.add(new Token("AXIOM", "$AXIOM"));
                    //parse.addAxiom(m.group(1));
                } else if(m.group(13) != null) {
                    System.out.println("TERM ("+strNum+","+pos+")-("+strNum+","+
                            (pos+m.end())+"): "+m.group(13));
                    tokens.add(new Token("T", "$TERM"));
                    //parse.addTerm(m.group(2));
                } else if(m.group(12) != null) {
                                System.out.println("NTERM ("+strNum+","+pos+")-("+strNum+","+
                                        (pos+m.end())+"): "+m.group(12));
                    tokens.add(new Token("N", "$NTERM"));
                    //parse.addNTerm(m.group(1));
                } else {
                                //System.out.println("RULES-to-be-continued ("+strNum+","+pos+")-("+strNum+","+
                                //        (pos+m.end())+"): "+m.group(3));
                    //System.out.println("RULEEEEEEEEEEEEEEEEEEEEEEEEEEE");
                    //for(int i = 0; i <= 13; i++)
                    //    System.out.println("group("+i+"): "+ m.group(i));
                    //findLex2(m.group(7), Pattern.compile("\\$RULE (([A-Z]{1,9}\\'{0,1}) =(([( [A-Z]{1,9}\\'{0,1})( \"[a-zA-Z=\\'\\\\]{1,9}\"| \"\"\"| \"\\*\"| \"\\+\"| \"\\(\"| \"\\)\")]+\\n| \\$EPS\\n)+))"));
                }
                pos += m.end();
                s = s.substring(m.end());
                //System.out.println("s: "+s);
                //System.out.println(s);
                //for(int i = 1; i< 7;i++)
                //    System.out.println("g: " +m.group(i));
            } else {
                pos++;
                if(s.charAt(0) != ' ') {
                    System.out.println("ERROR at (" + strNum + "," + pos + ")");
                }
                s = s.substring(1);
            }
        }
        strNum++;
    }

    public static void splitLexems(String rules) {

    }

    public static void main(String args[])
    {
        // Текст для сопоставления
        String text = "$AXIOM E\n" +
                "$TERM";

        // Регулярные выражения
        String nterm = "[A-Z]";
        String term = "\".\"";
        String keyword = "(\\$TERM)|(\\$NTERM)|(\\$RULE)|(\\()|(\\))|(\\{)|(\\})|(=)|(\\|)";

        String pattern = "^((" + keyword + ")|(" + nterm + ")|(" + term + ")| |\\n)";
        //String

        // Компиляция регулярного выражения
        Pattern p = Pattern.compile(pattern);

        Reader reader = new Reader("test.txt");//"test.txt");
        ArrayList<String> mas = reader.Read();
        //System.out.println(reader1.Read());
        // Сопоставление текста с регулярным выражением
        String program = "";
        for(String s: mas)
            program += (s+'\n');
        findLex(program, p);

        for (String s : mas) {
            //System.out.println();
            //findLex(s+'\n', p);
        }
    }
}