Subversion Repositories ao68000

/*
 * Copyright 2010, Aleksander Osman, alfik@poczta.fm. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without modification, are
 * permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright notice, this list of
 *     conditions and the following disclaimer.
 *
 *  2. 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 AUTHOR ``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 AUTHOR 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 ao68000_tool;
 
import java.io.File;
import java.io.FileInputStream;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.HashMap;
 
class ParseParams {
    /**
     * Parse microcode_params.v to get information about what to control with the microcode,
     * that is, about the microcode parameters.
     *
     * @param file_name         - path to microcode_params.v,
     * @return                  - the contents of Parser.java,
     * @throws Exception        - in case of file read error.
     */
    static String parse(String file_name) throws Exception {
        // load file
        File file = new File(file_name);
        byte bytes[] = new byte[(int)file.length()];
        FileInputStream in = new FileInputStream(file);
        if( in.read(bytes) != bytes.length ) throw new Exception("Can not read from file: " + file.getCanonicalPath());
        in.close();
 
        // find 'OPERATIONS START' and 'OPERATIONS END' substrings
        String all_string = new String(bytes);
        int start_index = all_string.indexOf("OPERATIONS START");
        if(start_index == -1) throw new Exception("Can not find 'OPERATIONS START' substring in " + file.getCanonicalPath());
        int end_index = all_string.indexOf("OPERATIONS END");
        if(end_index == -1) throw new Exception("Can not find 'OPERATIONS END' substring in " + file.getCanonicalPath());
 
        // prepare Parser.java header and constructors
        String java = "";
        java += "package ao68000_tool;" + "\n";
        java += "class Parser {" + "\n";
        java += "\t" + "boolean newline;" + "\n";
        java += "\t" + "Parser() { this(true); }" + "\n";
        java += "\t" + "Parser(boolean newline) { this.newline = newline; }" + "\n";
 
        // prepare data structures to keep information about the microcode parameters
        prefixes = new Vector<String>();
        prefix_locations = new HashMap<String, Integer>();
        name_values = new HashMap<String, Integer>();
 
        // split read file into lines
        String string = all_string.substring(start_index, end_index);
        String tokens[] = string.split("\\n");
 
        // prepare patterns, initialize counters
        Pattern pat = Pattern.compile("`define\\s*(\\S+)\\s*(\\d+)'d(\\d+).*");
        int last_parameter_size = 0;
        control_bit_offset = 0;
 
        // parse each line
        for(String s : tokens) {
            Matcher m0 = pat.matcher(s);
 
            // match parameter names and values
            if( m0.matches() ) {
                String name = m0.group(1);
                int size = Integer.parseInt(m0.group(2));
                int value = Integer.parseInt(m0.group(3));
 
                // check if parameter name ends with _IDLE
                if(name.endsWith("_IDLE")) {
                    last_parameter_size = size;
 
                    String prefix = name.substring(0, name.length()-5);
 
                    prefixes.add(prefix + "_");
                    prefix_locations.put(prefix + "_start", control_bit_offset);
                    prefix_locations.put(prefix + "_end", control_bit_offset+last_parameter_size-1);
                    control_bit_offset += last_parameter_size;
                }
                else {
                    java += "\t" + "Parser " + name + "() throws Exception {" + "\n";
                    java += "\t\t" + "GenerateMicrocode.entry(newline, \"" + name + "\");" + "\n";
                    java += "\t\t" + "return new Parser(false);" + "\n";
                    java += "\t" + "}" + "\n";
 
                    name_values.put(name, value);
                }
            }
        }
 
        // prepare Parser.java ending
        java += "\t" + "void label(String label) throws Exception { GenerateMicrocode.entry(newline, \"label_\" + label); }" + "\n";
        java += "\t" + "Parser offset(String label) throws Exception {" + "\n";
        java += "\t\t" + "GenerateMicrocode.entry(newline, \"offset_\" + label);" + "\n";
        java += "\t\t" + "return new Parser(false);" + "\n";
        java += "\t" + "}" + "\n";
 
        java += "}" + "\n";
 
        return java;
    }
 
    static Vector<String> prefixes;
    static HashMap<String, Integer> name_values;
    static HashMap<String, Integer> prefix_locations;
    static int control_bit_offset;
}