tools/org.eclipse.egf.emf.pattern.codegen/sandbox/parsejet/test2/CodegenJetParser.java

/**
 * <copyright>
 *
 *  Copyright (c) 2009-2010 Thales Corporate Services S.A.S.
 *  All rights reserved. This program and the accompanying materials
 *  are made available under the terms of the Eclipse Public License v1.0
 *  which accompanies this distribution, and is available at
 *  http://www.eclipse.org/legal/epl-v10.html
 * 
 *  Contributors:
 *      Thales Corporate Services S.A.S - initial API and implementation
 * 
 * </copyright>
 */

package parsejet.test2;

import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.emf.codegen.jet.JETCompiler;
import org.eclipse.emf.codegen.jet.JETException;
import org.eclipse.emf.codegen.jet.JETMark;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.dom.AST;
import org.eclipse.jdt.core.dom.ASTNode;
import org.eclipse.jdt.core.dom.ASTParser;
import org.eclipse.jdt.core.dom.Block;
import org.eclipse.jdt.core.dom.ClassInstanceCreation;
import org.eclipse.jdt.core.dom.EnhancedForStatement;
import org.eclipse.jdt.core.dom.IfStatement;

/**
 * @author Matthieu Helleboid
 * 
 */
public class CodegenJetParser extends JETCompiler {

    private static final String DIRECTIVE_JET = "jet"; //$NON-NLS-1$
    private static final String DIRECTIVE_INCLUDE = "include"; //$NON-NLS-1$
    private static final String DIRECTIVE_END = "end"; //$NON-NLS-1$
    private static final String DIRECTIVE_START = "start"; //$NON-NLS-1$

    private static final String ATTRIBUTE_FAIL = "fail"; //$NON-NLS-1$
    private static final String ATTRIBUTE_FILE = "file"; //$NON-NLS-1$

    private static final String FAIL_ALTERNATIVE = "alternative"; //$NON-NLS-1$
    private static final String FAIL_SILENT = "silent"; //$NON-NLS-1$

    private StringBuilder buffer = new StringBuilder();
    protected List<char[]> charsList = new ArrayList<char[]>();

    public CodegenJetParser(String templateURI) throws JETException {
        super(templateURI);
    }

    @Override
    public void parse() throws JETException {
        super.parse();
        findAstNodes();
    }

    @Override
    public void handleCharData(char[] chars) throws JETException {
        addMarkStatement(Mark.EGFMarkChars, this.charsList.size());
        this.charsList.add(chars);
    }

    @Override
    public void handleExpression(JETMark start, JETMark stop, Map<String, String> attributes) throws JETException {
        addMarkStatement(Mark.EGFMarkExpression, this.charsList.size());
        this.charsList.add(reader.getChars(start, stop));
    }

    @Override
    public void handleScriptlet(JETMark start, JETMark stop, Map<String, String> attributes) throws JETException {
        buffer.append(reader.getChars(start, stop));
        buffer.append("\n"); //$NON-NLS-1$
    }

    @Override
    public void handleDirective(String directive, JETMark start, JETMark stop, Map<String, String> attributes) throws JETException {
        if (DIRECTIVE_INCLUDE.equals(directive)) {
            String file = attributes.get(ATTRIBUTE_FILE);
            String fail = attributes.get(ATTRIBUTE_FAIL);

            if (FAIL_ALTERNATIVE.equals(fail)) {
                buffer.append("{\n"); //$NON-NLS-1$
                addMarkStatement(Mark.EGFMarkIncludeAlternative, file);
            } else if (FAIL_SILENT.equals(fail)) {
                addMarkStatement(Mark.EGFMarkIncludeSilent, file);
            } else {
                addMarkStatement(Mark.EGFMarkInclude, file);
            }
        } else if (DIRECTIVE_START.equals(directive)) {
            addMarkStatement(Mark.EGFMarkStart);
        } else if (DIRECTIVE_END.equals(directive)) {
            addMarkStatement(Mark.EGFMarkEnd);
            buffer.append("}\n"); //$NON-NLS-1$
        } else if (DIRECTIVE_JET.equals(directive)) {
            // ignore me
        } else
            throw new IllegalStateException("Unknown directive " + directive); //$NON-NLS-1$
    }

    protected void addMarkStatement(Mark mark, Object... attributes) {
        buffer.append("new "); //$NON-NLS-1$
        buffer.append(mark.toString());
        buffer.append("("); //$NON-NLS-1$
        for (int i = 0; i < attributes.length; i++) {
            Object attribute = attributes[i];
            buffer.append("\""); //$NON-NLS-1$
            buffer.append(attribute);
            buffer.append("\""); //$NON-NLS-1$
            if (i < attributes.length - 1)
                buffer.append(","); //$NON-NLS-1$
        }
        buffer.append(");\n"); //$NON-NLS-1$
    }

    protected void findAstNodes() {
        ASTParser astParser = ASTParser.newParser(AST.JLS3);
        astParser.setKind(ASTParser.K_STATEMENTS);
        astParser.setSource(buffer.toString().toCharArray());
        Map<String, String> options = new HashMap<String, String>();
        JavaCore.setComplianceOptions("1.5", options); //$NON-NLS-1$
        astParser.setCompilerOptions(options);
        ASTNode astNode = astParser.createAST(new NullProgressMonitor());

        StructureVisitor structureVisitor = new StructureVisitor(this);
        structureVisitor.section = new Section((Block) astNode);
        astNode.accept(structureVisitor);

        PrintVisitor printVisitor = new PrintVisitor(this);
        astNode.accept(printVisitor);

        try {
            FileWriter fileWriter = new FileWriter("C:/test");
            fileWriter.write(buffer.toString());
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        try {
            FileWriter fileWriter = new FileWriter("C:/test2");
            fileWriter.write(printVisitor.toString());
            fileWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }


        
        printSection(structureVisitor.section, 0);
    }

    List<ASTNode> nodes = new ArrayList<ASTNode>();

    private void printSection(Section section, int i) {
        for (int j = 0; j < i; j++)
            System.out.print("  ");

        System.out.print("section ");
        if (section.node instanceof ClassInstanceCreation) {
            ClassInstanceCreation cic = (ClassInstanceCreation) section.node;
            System.out.print(getMark(cic));
            System.out.print(" ");
            System.out.print(getArguments(cic).get(0));
        } else if (section.node instanceof EnhancedForStatement) {
            EnhancedForStatement efs = (EnhancedForStatement) section.node;
            System.out.print("foreach " + efs.getExpression());
        } else if (section.node instanceof IfStatement) {
            IfStatement is = (IfStatement) section.node;
            System.out.print("if " + is.getExpression());
        }

        for (ASTNode node : nodes)
            if (node == section.node)
                System.out.print("************");

        nodes.add(section.node);

        System.out.println("");

        for (Section subSection : section.subSections) {
            printSection(subSection, i + 1);
        }
    }

    protected Mark getMark(ClassInstanceCreation node) {
        try {
            return Mark.valueOf(node.getType().toString());
        } catch (Exception e) {
            return null;
        }
    }

    protected List<String> getArguments(ClassInstanceCreation node) {
        List<String> arguments = new ArrayList<String>();
        for (Object object : node.arguments()) {
            String string = object.toString();
            arguments.add(string.substring(1, string.length() - 1));
        }
        return arguments;
    }
}