Subversion Repositories ao486

/*

 * Copyright (c) 2014, Aleksander Osman

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * * Redistributions of source code must retain the above copyright notice, this

 *   list of conditions and the following disclaimer.

 *

 * * Redistributions in binary form must reproduce the above copyright notice,

 *   this list of conditions and the following disclaimer in the documentation

 *   and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package ao486;

import java.io.File;

import java.io.FileOutputStream;

import java.nio.file.Files;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.Stack;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

class Condition {

    Condition(int index, boolean negation, int level) {

        this.negation = negation;

        this.index = index;

        this.level = level;

    }

    Condition() {

    }

    @Override

    public Object clone() {

        Condition c = new Condition(index, negation, level);

        return c;

    }

    boolean negation;

    int     index;

    int     level;

}

class ConditionPoint {

    ConditionPoint(String name, Stack<Condition> stack, String value) throws Exception {

        this.name = name;

        this.value= value;

        conditions_stack = new Stack<>();

        for(int i=0; i<stack.size(); i++) {

            conditions_stack.push((Condition)stack.elementAt(i).clone());

        }

    }

    String           name;

    String           value;

    Stack<Condition> conditions_stack;

}

class Model {

    void IF(String condition) {

        int level = 0;

        if(conditions_stack.empty() == false) {

            level = conditions_stack.peek().level + 1;

        }

        // find previous

        for(int i=0; i<conditions.size(); i++) {

            String str = conditions.get(i);

            if(str.equals(condition)) {

                conditions_stack.push(new Condition(i, false, level));

                return;

            }

        }

        int index = conditions.size();

        conditions_stack.push(new Condition(index, false, level));

        conditions.add(condition);

    }

    void ELSE() {

        conditions_stack.peek().negation = true;

    }

    void ELSE_IF(String condition) {

        conditions_stack.peek().negation = true;

        int level = conditions_stack.peek().level;

        // find previous

        for(int i=0; i<conditions.size(); i++) {

            String str = conditions.get(i);

            if(str.equals(condition)) {

                conditions_stack.push(new Condition(i, false, level));

                return;

            }

        }

        int index = conditions.size();

        conditions_stack.push(new Condition(index, false, level));

        conditions.add(condition);

    }

    void ENDIF() {

        int level = conditions_stack.peek().level;

        while(conditions_stack.empty() == false && conditions_stack.peek().level == level) conditions_stack.pop();

    }

    void SET(String wire) throws Exception {

        SET(wire, "`TRUE");

    }

    void SAVE(String register, String value) throws Exception {

        saves.add(new ConditionPoint(register, conditions_stack, value));

    }

    void SET(String wire, String value) throws Exception {

        sets.add(new ConditionPoint(wire, conditions_stack, value));

    }

    void NO_ALWAYS_BLOCK(String register) throws Exception {

        no_always_block.add(register);

        //add register if signal also in wires

        if(wires.containsKey(register + "_to_reg")) {

            int size_w = wires.get(register + "_to_reg");

            if(registers.containsKey(register)) {

                int size_r = registers.get(register);

                if(size_w != size_r) throw new Exception("");

            }

            else {

                registers.put(register, size_w);

            }

        }

    }

    String convert_expression(String expression) {

        return expression;

    }

    String template(String string, Object... args) {

        for(int i=0; i<args.length; i++) {

            string = string.replaceAll("#" + (i+1), args[i].toString());

        }

        return string;

    }

    String generate() throws Exception {

        StringBuilder build = new StringBuilder();

        build.append("//======================================================== conditions\n");

        for(int i=0; i<conditions.size(); i++) {

            String condition = conditions.get(i);

            condition = convert_expression(condition);

            build.append(template("wire cond_#1 = #2;\n", i, condition));

        }

        build.append("//======================================================== saves\n");

        HashMap<String, StringBuilder> to_regs_map = new HashMap<>();

        for(ConditionPoint point : saves) {

            String condition = "";

            for(Condition cond : point.conditions_stack) {

                if(condition.length() > 0) condition += " && ";

                condition += ((cond.negation)? "~" : "") + ("cond_" + cond.index);

            }

            if(condition.length() == 0) throw new Exception("Invalid SAVE(): no condition.");

            String name  = convert_expression(point.name);

            String value = convert_expression(point.value);

            StringBuilder builder = to_regs_map.get(name);

            if(builder == null) {

                builder = new StringBuilder();

                to_regs_map.put(name, builder);

            }

            builder.append(template("    (#1)? (#2) :\n", condition,value));

        }

        for(String name : to_regs_map.keySet()) {

            if(registers.containsKey(name) == false) throw new Exception("Save to unknown register: " + name);

            int size = registers.get(name);

            String header = "wire #1";

            if(wires.containsKey(name + "_to_reg")) header = "assign";

            build.append(template(header + " #2_to_reg =\n", (size > 1)? "[" + (size-1) + ":0]" : "", name));

            build.append(to_regs_map.get(name));

            build.append(template("    #1;\n", name));

        }

        build.append("//======================================================== always\n");

        for(String name : to_regs_map.keySet()) {

            if(registers.containsKey(name) == false) throw new Exception("Save to unknown register: " + name);

            int size = registers.get(name);

            if(no_always_block.contains(name)) continue;

            build.append(template("always @(posedge clk or negedge rst_n) begin\n"));

            build.append(template("    if(rst_n == 1'b0) #1 <= #2'd0;\n", name, "" + size));

            build.append(template("    else              #1 <= #1_to_reg;\n", name));

            build.append(template("end\n"));

        }

        build.append("//======================================================== sets\n");

        HashMap<String, StringBuilder> to_wires_map = new HashMap<>();

        for(ConditionPoint point : sets) {

            String condition = "";

            for(Condition cond : point.conditions_stack) {

                if(condition.length() > 0) condition += " && ";

                condition += ((cond.negation)? "~" : "") + ("cond_" + cond.index);

            }

            if(condition.length() == 0) throw new Exception("Invalid SET(): no condition.");

            String name  = convert_expression(point.name);

            String value = convert_expression(point.value);

            StringBuilder builder = to_wires_map.get(name);

            if(builder == null) {

                builder = new StringBuilder();

                to_wires_map.put(name, builder);

            }

            builder.append(template("    (#1)? (#2) :\n", condition,value));

        }

        for(String name : to_wires_map.keySet()) {

            if(wires.containsKey(name) == false) throw new Exception("Set to unknown wire: " + name);

            int size = wires.get(name);

            build.append(template("assign #1 =\n", name));

            build.append(to_wires_map.get(name));

            build.append(template("    #1'd0;\n", "" + size));

        }

        return build.toString();

    }

    Stack<Condition>            conditions_stack= new Stack<>();

    LinkedList<String>          conditions      = new LinkedList<>();

    LinkedList<ConditionPoint>  sets            = new LinkedList<>();

    LinkedList<ConditionPoint>  saves           = new LinkedList<>();

    HashMap<String, Integer>    registers       = new HashMap<>();

    HashMap<String, Integer>    wires           = new HashMap<>();

    HashSet<String>             no_always_block = new HashSet<>();

}

public class AutogenGenerator {

    static String strip(String string, String pattern) {

        Pattern p = Pattern.compile(pattern);

        Matcher m = p.matcher(string);

        StringBuffer sb = new StringBuffer();

        while (m.find()) {

            m.appendReplacement(sb, "");

        }

        m.appendTail(sb);

        return sb.toString();

    }

    static void findRegsAndWires(String source, Model model) {

        // strip comments

        source = strip(source, "//[^\\n]*");

        // regs

        Matcher reg_single = Pattern.compile("reg\\s+(\\w+)\\s*;").matcher(source);

        while(reg_single.find()) model.registers.put(reg_single.group(1), 1);

        Matcher reg_vector = Pattern.compile("reg\\s+\\[(\\d+)\\s*:\\s*0\\s*\\]\\s*(\\w+)\\s*;").matcher(source);

        while(reg_vector.find()) model.registers.put(reg_vector.group(2), Integer.parseInt(reg_vector.group(1))+1);

        Matcher out_reg_single = Pattern.compile("output\\s+reg\\s+(\\w+)\\s*[,\\)\\s]").matcher(source);

        while(out_reg_single.find()) model.registers.put(out_reg_single.group(1), 1);

        Matcher out_reg_vector = Pattern.compile("output\\s+reg\\s+\\[(\\d+)\\s*:\\s*0\\s*\\]\\s*(\\w+)\\s*[,\\)\\s]").matcher(source);

        while(out_reg_vector.find()) model.registers.put(out_reg_vector.group(2), Integer.parseInt(out_reg_vector.group(1))+1);

        //wires

        Matcher wire_single = Pattern.compile("wire\\s+(\\w+)\\s*;").matcher(source);

        while(wire_single.find()) model.wires.put(wire_single.group(1), 1);

        Matcher wire_vector = Pattern.compile("wire\\s+\\[(\\d+)\\s*:\\s*0\\s*\\]\\s*(\\w+)\\s*;").matcher(source);

        while(wire_vector.find()) model.wires.put(wire_vector.group(2), Integer.parseInt(wire_vector.group(1))+1);

        Matcher out_wire_single = Pattern.compile("output\\s+(\\w+)\\s*[,\\)\\s]").matcher(source);

        while(out_wire_single.find()) model.wires.put(out_wire_single.group(1), 1);

        Matcher out_wire_vector = Pattern.compile("output\\s+\\[(\\d+)\\s*:\\s*0\\s*\\]\\s*(\\w+)\\s*[,\\)\\s]").matcher(source);

        while(out_wire_vector.find()) model.wires.put(out_wire_vector.group(2), Integer.parseInt(out_wire_vector.group(1))+1);

    }

    static void parseScript(String script, Model model) throws Exception {

        // strip comments

        script = strip(script, "//[^\\n]*");

        // strip start and end whitespace

        script = script.trim();

        Pattern if_pattern       = Pattern.compile("(?s)^\\s*IF\\s*\\((.*?)\\)\\s*;");

        Pattern set_true_pattern = Pattern.compile("^\\s*SET\\s*\\((.*?)\\)\\s*;");

        Pattern set_pattern      = Pattern.compile("(?s)^\\s*SET\\s*\\(([^,\\)]*),(.*?)\\)\\s*;");

        Pattern save_pattern     = Pattern.compile("(?s)^\\s*SAVE\\s*\\(([^,\\)]*),(.*?)\\)\\s*;");

        Pattern endif_pattern    = Pattern.compile("^\\s*ENDIF\\s*\\(\\s*\\)\\s*;");

        Pattern else_pattern     = Pattern.compile("^\\s*ELSE\\s*\\(\\s*\\)\\s*;");

        Pattern elseif_pattern   = Pattern.compile("(?s)^\\s*ELSE_IF\\s*\\((.*?)\\)\\s*;");

        Pattern no_always_pattern= Pattern.compile("^\\s*NO_ALWAYS_BLOCK\\s*\\((.*?)\\)\\s*;");

        while(true) {

            Matcher if_matcher       = if_pattern.matcher(script);

            Matcher set_true_matcher = set_true_pattern.matcher(script);

            Matcher set_matcher      = set_pattern.matcher(script);

            Matcher save_matcher     = save_pattern.matcher(script);

            Matcher endif_matcher    = endif_pattern.matcher(script);

            Matcher else_matcher     = else_pattern.matcher(script);

            Matcher elseif_matcher   = elseif_pattern.matcher(script);

            Matcher no_always_matcher= no_always_pattern.matcher(script);

            if(if_matcher.find()) {

                model.IF(if_matcher.group(1));

                script = script.substring(if_matcher.end());

            }

            else if(set_matcher.find()) {

                model.SET(set_matcher.group(1), set_matcher.group(2));

                script = script.substring(set_matcher.end());

            }

            else if(set_true_matcher.find()) {

                model.SET(set_true_matcher.group(1));

                script = script.substring(set_true_matcher.end());

            }

            else if(save_matcher.find()) {

                model.SAVE(save_matcher.group(1), save_matcher.group(2));

                script = script.substring(save_matcher.end());

            }

            else if(endif_matcher.find()) {

                model.ENDIF();

                script = script.substring(endif_matcher.end());

            }

            else if(else_matcher.find()) {

                model.ELSE();

                script = script.substring(else_matcher.end());

            }

            else if(elseif_matcher.find()) {

                model.ELSE_IF(elseif_matcher.group(1));

                script = script.substring(elseif_matcher.end());

            }

            else if(no_always_matcher.find()) {

                model.NO_ALWAYS_BLOCK(no_always_matcher.group(1));

                script = script.substring(no_always_matcher.end());

            }

            else break;

        }

        if(model.conditions_stack.empty() == false) throw new Exception("Condition stack not empty: " +

                model.conditions.get(model.conditions_stack.peek().index));

        if(script.length() > 0) throw new Exception("Left not empty: " + script);

    }

    static void process_file(File file) throws Exception {

        byte file_bytes[] = Files.readAllBytes(file.toPath());

        String file_string = new String(file_bytes);

        if(file_string.indexOf("//PARSED_COMMENTS") == -1) return;

        System.out.println("Processing file: " + file);

        String start_string = "/*******************************************************************************SCRIPT";

        String end_string   = "*/";

        int index = 0;

        Model model = new Model();

        findRegsAndWires(file_string, model);

        while(true) {

            index = file_string.indexOf(start_string, index);

            if(index == -1) break;

            index += start_string.length();

            int end = file_string.indexOf(end_string, index);

            if(end == -1) throw new Exception("Invalid script: end string not found.");

            String script = file_string.substring(index, end);

            parseScript(script, model);

        }

        // expand macros

        if(file.getName().toLowerCase().equals("decode_commands.v")) {

            String script = Commands.decode.toString();

            parseScript(script, model);

        }

        if(file.getName().toLowerCase().equals("microcode_commands.v")) {

            String script = Commands.microcode.toString();

            //System.out.println("microcode:\n" + script);

            parseScript(script, model);

        }

        if(file.getName().toLowerCase().equals("read_commands.v")) {

            String script = Commands.read.toString();

            //System.out.println("microcode:\n" + script);

            parseScript(script, model);

        }

        if(file.getName().toLowerCase().equals("execute_commands.v")) {

            String script = Commands.execute.toString();

            //System.out.println("execute:\n" + script);

            parseScript(script, model);

        }

        if(file.getName().toLowerCase().equals("write_commands.v")) {

            String script = Commands.write.toString();

            //System.out.println("execute:\n" + script);

            parseScript(script, model);

        }

        // get old contents

        File autogen_file = new File(autogen_dir.getCanonicalPath() + "/" + file.getName());

        String old_contents = "";

        if(autogen_file.exists()) {

            old_contents = new String(Files.readAllBytes(autogen_file.toPath()));

        }

        // generate new contents

        String new_contents = model.generate();

        if(file.getName().toLowerCase().equals("read_commands.v")) {

            new_contents = Commands.read_local + new_contents;

        }

        if(file.getName().toLowerCase().equals("execute_commands.v")) {

            new_contents = Commands.execute_local + new_contents;

        }

        if(file.getName().toLowerCase().equals("write_commands.v")) {

            new_contents = Commands.write_local + new_contents;

        }

        if(new_contents.equals(old_contents) == false) {

            FileOutputStream out = new FileOutputStream(autogen_file);

            out.write(new_contents.getBytes());

            out.close();

        }

    }

    static void recurrent(File directory) throws Exception {

        for(File file : directory.listFiles()) {

            if(file.isDirectory()) {

                recurrent(file);

                continue;

            }

            // skip autogen files

            if(file.getCanonicalPath().indexOf("autogen") != -1) continue;

            process_file(file);

        }

    }

    static void process_defines() throws Exception {

        File defines_file = new File(autogen_dir.getCanonicalPath() + "/" + "defines.v");

        String old_contents = "";

        if(defines_file.exists()) {

            old_contents = new String(Files.readAllBytes(defines_file.toPath()));

        }

        StringBuilder new_contents = new StringBuilder();

        for(String key : Commands.defines.keySet()) {

            new_contents.append("`define " + key + " " + Commands.defines.get(key) + "\n");

        }

        if(new_contents.toString().equals(old_contents) == false) {

            FileOutputStream out = new FileOutputStream(defines_file);

            out.write(new_contents.toString().getBytes());

            out.close();

        }

    }

    public static void main(String args[]) throws Exception {

        File rtl_dir = new File("./../rtl/ao486");

        File cmd_dir = new File("./../rtl/ao486/commands");

        autogen_dir = new File("./../rtl/ao486/autogen");

        Commands.read_command_files(cmd_dir);

        process_defines();

        recurrent(rtl_dir);

    }

    static File autogen_dir;

}